activeadmin 2.2.0

data/lib/active_admin/filters.rb

@@ -0,0 +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/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::ViewHelpers.send :include, ActiveAdmin::Filters::ViewHelper

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,124 @@
+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]
+      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

@@ -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/dsl.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module Filters
+    module DSL
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#add_filter
+      def filter(attribute, options = {})
+        config.add_filter(attribute, options)
+      end
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#remove_filter
+      def remove_filter(*attributes)
+        config.remove_filter(*attributes)
+      end
+
+      # For docs, please see ActiveAdmin::Filters::ResourceExtension#preserve_default_filters!
+      def preserve_default_filters!
+        config.preserve_default_filters!
+      end
+    end
+  end
+end

data/lib/active_admin/filters/forms.rb

@@ -0,0 +1,85 @@
+module ActiveAdmin
+  module Filters
+    # This form builder defines methods to build filter forms such
+    # as the one found in the sidebar of the index page of a standard resource.
+    class FormBuilder < ::ActiveAdmin::FormBuilder
+      include ::ActiveAdmin::Filters::FormtasticAddons
+      self.input_namespaces = [::Object, ::ActiveAdmin::Inputs::Filters, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
+
+      # TODO: remove input class finders after formtastic 4 (where it will be default)
+      self.input_class_finder = ::Formtastic::InputClassFinder
+
+      def filter(method, options = {})
+        if method.present? && options[:as] ||= default_input_type(method)
+          template.concat input(method, options)
+        end
+      end
+
+      protected
+
+      # Returns the default filter type for a given attribute. If you want
+      # to use a custom search method, you have to specify the type yourself.
+      def default_input_type(method, options = {})
+        if method =~ /_(eq|equals|cont|contains|start|starts_with|end|ends_with)\z/
+          :string
+        elsif klass._ransackers.key?(method.to_s)
+          klass._ransackers[method.to_s].type
+        elsif reflection_for(method) || polymorphic_foreign_type?(method)
+          :select
+        elsif column = column_for(method)
+          case column.type
+          when :date, :datetime
+            :date_range
+          when :string, :text
+            :string
+          when :integer, :float, :decimal
+            :numeric
+          when :boolean
+            :boolean
+          end
+        end
+      end
+    end
+
+    # This module is included into the view
+    module ViewHelper
+
+      # 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: 'filter_form' } }
+        required = { html: { method: :get },
+                     as: :q }
+        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])
+
+            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') +
+              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
+end

data/lib/active_admin/filters/formtastic_addons.rb

@@ -0,0 +1,79 @@
+module ActiveAdmin
+  module Filters
+    module FormtasticAddons
+
+      #
+      # The below are Formtastic method overrides that jump inside of the Ransack
+      # search object to get at the object being searched upon.
+      #
+
+      def humanized_method_name
+        if klass.respond_to?(:human_attribute_name)
+          klass.human_attribute_name(method)
+        else
+          method.to_s.public_send(builder.label_str_method)
+        end
+      end
+
+      def reflection_for(method)
+        klass.reflect_on_association(method) if klass.respond_to? :reflect_on_association
+      end
+
+      def column_for(method)
+        klass.columns_hash[method.to_s] if klass.respond_to? :columns_hash
+      end
+
+      def column
+        column_for method
+      end
+
+      #
+      # The below are custom methods that Formtastic does not provide.
+      #
+
+      # The resource class, unwrapped from Ransack
+      def klass
+        @object.object.klass
+      end
+
+      def polymorphic_foreign_type?(method)
+        klass.reflect_on_all_associations.select { |r| r.macro == :belongs_to && r.options[:polymorphic] }
+          .map(&:foreign_type).include? method.to_s
+      end
+
+      #
+      # These help figure out whether the given method or association will be recognized by Ransack.
+      #
+
+      def searchable_has_many_through?
+        if reflection && reflection.options[:through]
+          reflection.through_reflection.klass.ransackable_attributes.include? reflection.foreign_key
+        else
+          false
+        end
+      end
+
+      def seems_searchable?
+        has_predicate? || scope?
+      end
+
+      # If the given method has a predicate (like _eq or _lteq), it's pretty
+      # likely we're dealing with a valid search method.
+      def has_predicate?
+        !!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
+        context.respond_to?(:ransackable_scope?) && context.ransackable_scope?(method.to_s, klass)
+      end
+
+    end
+  end
+end

data/lib/active_admin/filters/resource_extension.rb

@@ -0,0 +1,155 @@
+module ActiveAdmin
+  module Filters
+
+    class Disabled < RuntimeError
+      def initialize
+        super "Can't remove a filter when filters are disabled. Enable filters with 'config.filters = true'"
+      end
+    end
+
+    module ResourceExtension
+
+      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 hash.
+      #
+      # @return [Hash] Filters that apply for this resource
+      def filters
+        filters_enabled? ? filter_lookup : {}
+      end
+
+      # Setter to enable / disable filters on this resource.
+      #
+      # Set to `nil` to inherit the setting from the namespace
+      def filters=(bool)
+        @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
+
+      def preserve_default_filters?
+        @preserve_default_filters == true
+      end
+
+      # Remove a filter for this resource. If filters are not enabled, this method
+      # will raise a RuntimeError
+      #
+      # @param [Symbol] attributes The attributes to not filter on
+      def remove_filter(*attributes)
+        raise Disabled unless filters_enabled?
+
+        attributes.each { |attribute| (@filters_to_remove ||= []) << attribute.to_sym }
+      end
+
+      # Add a filter for this resource. If filters are not enabled, this method
+      # will raise a RuntimeError
+      #
+      # @param [Symbol] attribute The attribute to filter on
+      # @param [Hash] options The set of options that are passed through to
+      #                       ransack for the field definition.
+      def add_filter(attribute, options = {})
+        raise Disabled unless filters_enabled?
+
+        (@filters ||= {})[attribute.to_sym] = options
+      end
+
+      # Reset the filters to use defaults
+      def reset_filters!
+        @filters = nil
+        @filters_to_remove = nil
+      end
+
+      private
+
+      # Collapses the waveform, if you will, of which filters should be displayed.
+      # Removes filters and adds in default filters as desired.
+      def filter_lookup
+        filters = @filters.try(:dup) || {}
+
+        if filters.empty? || preserve_default_filters?
+          default_filters.each do |f|
+            filters[f] ||= {}
+          end
+        end
+
+        if @filters_to_remove
+          @filters_to_remove.each &filters.method(:delete)
+        end
+
+        filters
+      end
+
+      # @return [Array] The array of default filters for this resource
+      def default_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
+        if resource_class.respond_to?(:_ransackers)
+          resource_class._ransackers.keys.map(&:to_sym)
+        else
+          []
+        end
+      end
+
+      # 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] }
+
+          # remove deeply nested associations
+          not_poly.reject! { |r| r.chain.length > 2 }
+
+          filters = poly.map(&:foreign_type) + not_poly.map(&:name)
+          filters.map &:to_sym
+        else
+          []
+        end
+      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
+        end
+      end
+
+      def add_search_status_sidebar_section
+        self.sidebar_sections << ActiveAdmin::Filters::ActiveSidebar.new
+      end
+
+    end
+
+  end
+end