activeadmin 1.0.0.pre1 → 2.9.0

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
 
@@ -108,7 +101,7 @@ module ActiveAdmin
     def batch_action(title, options = {}, &block)
       # Create symbol & title information
       if title.is_a? String
-        sym = title.titleize.tr(' ', '').underscore.to_sym
+        sym = title.titleize.tr(" ", "").underscore.to_sym
       else
         sym = title
         title = sym.to_s.titleize
@@ -116,7 +109,7 @@ module ActiveAdmin
 
       # Either add/remove the batch action
       unless options == false
-        config.add_batch_action( sym, title, options, &block )
+        config.add_batch_action(sym, title, options, &block)
       else
         config.remove_batch_action sym
       end
@@ -128,7 +121,7 @@ module ActiveAdmin
       config.menu_item_options = options
     end
 
-    # Set the name of the navigation menu to display. This is mainly used in conjuction with the
+    # Set the name of the navigation menu to display. This is mainly used in conjunction with the
     # `#belongs_to` functionality.
     #
     # @param [Symbol] menu_name The name of the menu to display as the global navigation
@@ -137,7 +130,7 @@ module ActiveAdmin
     # Pass a block returning the name of a menu you want rendered for the request, being
     # executed in the context of the controller
     #
-    def navigation_menu(menu_name=nil, &block)
+    def navigation_menu(menu_name = nil, &block)
       config.navigation_menu_name = menu_name || block
     end
 
@@ -163,11 +156,5 @@ module ActiveAdmin
       config.sidebar_sections << ActiveAdmin::SidebarSection.new(name, options, &block)
     end
 
-    def decorate_with(decorator_class)
-      # Force storage as a string. This will help us with reloading issues.
-      # Assuming decorator_class.to_s will return the name of the class allows
-      # us to handle a string or a class.
-      config.decorator_class_name = "::#{ decorator_class }"
-    end
   end
 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,16 +1,23 @@
 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
-      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

@@ -5,8 +5,10 @@ module ActiveAdmin
   class AccessDenied < StandardError
     attr_reader :user, :action, :subject
 
-    def initialize(user, action, subject)
-      @user, @action, @subject = user, action, subject
+    def initialize(user, action, subject = nil)
+      @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
 
@@ -33,7 +35,7 @@ module ActiveAdmin
       super "Your file, #{file} (line #{line}), caused a database error while Active Admin was loading. This " +
             "is most common when your database is missing or doesn't have the latest migrations applied. To " +
             "prevent this error, move the code to a place where it will only be run when a page is rendered. " +
-            "One solution can be, to wrap the query in a Proc." +
+            "One solution can be, to wrap the query in a Proc. " +
             "Original error message: #{exception.message}"
     end
 
@@ -43,8 +45,6 @@ module ActiveAdmin
       raise new exception
     end
 
-    private
-
     def self.database_error_classes
       @classes ||= []
     end

data/lib/active_admin/filters/active.rb

@@ -0,0 +1,29 @@
+require "active_admin/filters/active_filter"
+
+module ActiveAdmin
+  module Filters
+
+    class Active
+      attr_accessor :filters, :resource
+
+      # Instantiate a `Active` object containing collection of current active filters
+
+      # @param resource [ActiveAdmin::Resource] current resource
+      # @param search [Ransack::Search] search object
+      #
+      # @see ActiveAdmin::ResourceController::DataAcces#apply_filtering
+      def initialize(resource, search)
+        @resource = resource
+        @filters = build_filters(search.conditions)
+      end
+
+      private
+
+      def build_filters(conditions)
+        conditions.map { |condition| ActiveFilter.new(resource, condition.dup) }
+      end
+
+    end
+
+  end
+end

data/lib/active_admin/filters/active_filter.rb

@@ -0,0 +1,123 @@
+module ActiveAdmin
+  module Filters
+
+    class ActiveFilter
+      include ActiveAdmin::ViewHelpers
+
+      attr_reader :resource, :condition, :related_class
+
+      # Instantiate a `ActiveFilter`
+      #
+      # @param resource [ActiveAdmin::Resource] current resource
+      # @param condition [Ransack::Nodes::Condition] applied ransack condition
+      def initialize(resource, condition)
+        @resource = resource
+        @condition = condition
+        @related_class = find_class if find_class?
+      end
+
+      def values
+        condition_values = condition.values.map(&:value)
+        if related_class
+          related_class.where(related_primary_key => condition_values)
+        else
+          condition_values
+        end
+      end
+
+      def 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}"
+        else
+          "#{attribute_name} #{translated_predicate}"
+        end.strip
+      end
+
+      def predicate_name
+        I18n.t(
+          "active_admin.filters.predicates.#{condition.predicate.name}",
+          default: ransack_predicate_name)
+      end
+
+      def html_options
+        { class: "current_filter current_filter_#{condition.key}" }
+      end
+
+      private
+
+      def resource_class
+        resource.resource_class
+      end
+
+      def attribute_name
+        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]
+      end
+
+      def name
+        condition_attribute.attr_name
+      end
+
+      def ransack_predicate_name
+        Ransack::Translate.predicate(condition.predicate.name)
+      end
+
+      def find_class?
+        ["eq", "in"].include? condition.predicate.arel_predicate
+      end
+
+      # detect related class for Ransack::Nodes::Attribute
+      def find_class
+        if condition_attribute.klass != resource_class && condition_attribute.klass.primary_key == name.to_s
+          condition_attribute.klass
+        elsif predicate_association
+          predicate_association.klass
+        end
+      end
+
+      def filter
+        resource.filters[name.to_sym] || resource.filters[condition.key.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
+
+      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

@@ -0,0 +1,54 @@
+require "active_admin/filters/active"
+
+module ActiveAdmin
+  module Filters
+    class ActiveSidebar < ActiveAdmin::SidebarSection
+
+      def initialize
+        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
+      end
+
+      def title
+        I18n.t("active_admin.search_status.headline")
+      end
+
+      protected
+
+      def sidebar_options
+        { only: :index, if: -> { active_admin_config.current_filters_enabled? && (params[:q] || params[:scope]) } }
+      end
+
+    end
+  end
+end

data/lib/active_admin/filters/forms.rb

@@ -41,7 +41,6 @@ module ActiveAdmin
       end
     end
 
-
     # This module is included into the view
     module ViewHelper
 
@@ -49,29 +48,37 @@ 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])
+            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, opts.except(:if, :unless)
+            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') +
-              hidden_field_tags_for(params, except: [:q, :page])
+            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
 
           f.template.concat buttons
         end
       end
 
+      private
+
+      def except_hidden_fields
+        [:q, :page]
+      end
     end
 
   end

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
 
@@ -54,7 +54,7 @@ module ActiveAdmin
       end
 
       def seems_searchable?
-        has_predicate? || ransacker? || 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 +63,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

@@ -12,10 +12,11 @@ module ActiveAdmin
       def initialize(*)
         super
         add_filters_sidebar_section
+        add_search_status_sidebar_section
       end
 
       # Returns the filters for this resource. If filters are not enabled,
-      # it will always return an empty array.
+      # it will always return an empty hash.
       #
       # @return [Hash] Filters that apply for this resource
       def filters
@@ -29,11 +30,23 @@ module ActiveAdmin
         @filters_enabled = bool
       end
 
+      # Setter to enable/disable showing current filters on this resource.
+      #
+      # Set to `nil` to inherit the setting from the namespace
+      def current_filters=(bool)
+        @current_filters_enabled = bool
+      end
+
       # @return [Boolean] If filters are enabled for this resource
       def filters_enabled?
         @filters_enabled.nil? ? namespace.filters : @filters_enabled
       end
 
+      # @return [Boolean] If show current filters are enabled for this resource
+      def current_filters_enabled?
+        @current_filters_enabled.nil? ? namespace.current_filters : @current_filters_enabled
+      end
+
       def preserve_default_filters!
         @preserve_default_filters = true
       end
@@ -70,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.
@@ -92,7 +105,11 @@ module ActiveAdmin
 
       # @return [Array] The array of default filters for this resource
       def default_filters
-        default_association_filters + default_content_filters + custom_ransack_filters
+        result = []
+        result.concat default_association_filters if namespace.include_default_association_filters
+        result.concat content_columns
+        result.concat custom_ransack_filters
+        result
       end
 
       def custom_ransack_filters
@@ -106,25 +123,40 @@ 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
 
-      # Returns a default set of filters for the content columns
-      def default_content_filters
-        if resource_class.respond_to? :content_columns
-          resource_class.content_columns.map{ |c| c.name.to_sym }
-        else
-          []
-        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
@@ -132,11 +164,15 @@ module ActiveAdmin
       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
 
+      def add_search_status_sidebar_section
+        self.sidebar_sections << ActiveAdmin::Filters::ActiveSidebar.new
+      end
+
     end
 
   end

data/lib/active_admin/filters.rb

@@ -1,9 +1,11 @@
-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/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