activeadmin 1.0.0.pre4 → 2.4.0

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,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)
 
@@ -59,7 +58,10 @@ module ActiveAdmin
             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])
 
-            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
 
@@ -54,7 +54,7 @@ module ActiveAdmin
       end
 
       def seems_searchable?
-        has_predicate? || ransacker? || scope?
+        has_predicate? || scope?
       end
 
       # If the given method has a predicate (like _eq or _lteq), it's pretty

data/lib/active_admin/filters/resource_extension.rb

@@ -1,5 +1,3 @@
-require 'active_admin/filters/active'
-
 module ActiveAdmin
   module Filters
 
@@ -85,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.
@@ -109,7 +107,7 @@ module ActiveAdmin
       def default_filters
         result = []
         result.concat default_association_filters if namespace.include_default_association_filters
-        result.concat default_content_filters
+        result.concat content_columns
         result.concat custom_ransack_filters
         result
       end
@@ -125,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
@@ -151,43 +164,15 @@ module ActiveAdmin
       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
 
       def add_search_status_sidebar_section
-        if current_filters_enabled?
-          self.sidebar_sections << search_status_section
-        end
+        self.sidebar_sections << ActiveAdmin::Filters::ActiveSidebar.new
       end
 
-      def search_status_section
-        ActiveAdmin::SidebarSection.new I18n.t("active_admin.search_status.headline"), only: :index, if: -> { params[:q] || params[:scope] } do
-          active = ActiveAdmin::Filters::Active.new(resource_class, params)
-
-          span do
-            h4 I18n.t("active_admin.search_status.current_scope"), style: 'display: inline'
-            b active.scope, style: "display: inline"
-
-            div style: "margin-top: 10px" do
-              h4 I18n.t("active_admin.search_status.current_filters"), style: 'margin-bottom: 10px'
-              ul do
-                if active.filters.blank?
-                  li I18n.t("active_admin.search_status.no_current_filters")
-                else
-                  active.filters.each do |filter|
-                    li do
-                      span filter.body
-                      b filter.value
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
     end
 
   end

data/lib/active_admin/filters.rb

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

data/lib/active_admin/form_builder.rb

@@ -13,13 +13,14 @@ end
 
 module ActiveAdmin
   class FormBuilder < ::Formtastic::FormBuilder
+
     self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
 
     # TODO: remove both class finders after formtastic 4 (where it will be default)
     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
       template.content_tag(:li, li_content, li_attrs)
@@ -27,109 +28,142 @@ module ActiveAdmin
 
     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
+
+    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.capture do
-        contents = "".html_safe
-        form_block = proc do |has_many_form|
-          index    = parent_child_index options[:parent] if options[:parent]
-          block.call has_many_form, index
-          template.concat has_many_actions(has_many_form, builder_options, "".html_safe)
-        end
-        
-        template.assign(has_many_block: true)
-        contents = without_wrapper { inputs(options, &form_block) } || "".html_safe
-
-        if builder_options[:new_record]
-          contents << js_for_has_many(assoc, form_block, template, builder_options[:new_record], options[:class])
-        else
-          contents
-        end
-      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)
+      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
 
     protected
 
-    def has_many_actions(has_many_form, builder_options, contents)
-      if has_many_form.object.new_record?
+    # 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)
+      options
+    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
+
+      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
+
+    # 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(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'
         end
-      elsif builder_options[:allow_destroy]
-        has_many_form.input(:_destroy, as: :boolean,
-                            wrapper_html: {class: '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
-          "MOVE"
+          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
+    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 }
+      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: {
@@ -137,5 +171,12 @@ module ActiveAdmin
       }
     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

data/lib/active_admin/generators/boilerplate.rb

@@ -9,8 +9,16 @@ module ActiveAdmin
         @class_name.constantize.new.attributes.keys
       end
 
+      def assignable_attributes
+        attributes - %w(id created_at updated_at)
+      end
+
+      def permit_params
+        assignable_attributes.map { |a| a.to_sym.inspect }.join(', ')
+      end
+
       def rows
-        attributes.map { |a| row(a) }.join("\n")
+        attributes.map { |a| row(a) }.join("\n  ")
       end
 
       def row(name)
@@ -18,7 +26,7 @@ module ActiveAdmin
       end
 
       def columns
-        attributes.map { |a| column(a) }.join("\n")
+        attributes.map { |a| column(a) }.join("\n  ")
       end
 
       def column(name)
@@ -26,7 +34,7 @@ module ActiveAdmin
       end
 
       def filters
-        attributes.map { |a| filter(a) }.join("\n")
+        attributes.map { |a| filter(a) }.join("\n  ")
       end
 
       def filter(name)
@@ -34,7 +42,7 @@ module ActiveAdmin
       end
 
       def form_inputs
-        attributes.reject{|a| %w(id created_at updated_at).include? a}.map{ |a| form_input(a) }.join("\n")
+        assignable_attributes.map { |a| form_input(a) }.join("\n  ")
       end
 
       def form_input(name)

data/lib/active_admin/helpers/collection.rb

@@ -4,6 +4,8 @@ module ActiveAdmin
       # 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)
+
         c = c.except :select, :order
 
         c.group_values.present? ? c.count.count : c.count

data/lib/active_admin/helpers/scope_chain.rb

@@ -1,5 +1,6 @@
 module ActiveAdmin
   module ScopeChain
+    private
     # Scope an ActiveRecord::Relation chain
     #
     # Example:

data/lib/active_admin/inputs/datepicker_input.rb

@@ -9,12 +9,19 @@ module ActiveAdmin
         end
       end
 
+      # Can pass proc to filter label option
+      def label_from_options
+        res = super
+        res = res.call if res.is_a? Proc
+        res
+      end
+
       private
-        def datepicker_options
-          options = self.options.fetch(:datepicker_options, {})
-          options = Hash[options.map{ |k, v| [k.to_s.camelcase(:lower), v] }]
-          { datepicker_options: options }
-        end
+      def datepicker_options
+        options = self.options.fetch(:datepicker_options, {})
+        options = Hash[options.map { |k, v| [k.to_s.camelcase(:lower), v] }]
+        { datepicker_options: options }
+      end
     end
   end
 end

data/lib/active_admin/inputs/filters/base/search_method_select.rb

@@ -57,8 +57,8 @@ module ActiveAdmin
 
           def current_filter
             @current_filter ||= begin
-              methods = filters.map{ |f| "#{method}_#{f}" }
-              methods.detect{ |m| @object.public_send m } || methods.first
+              methods = filters.map { |f| "#{method}_#{f}" }
+              methods.detect { |m| @object.public_send m } || methods.first
             end
           end
 

data/lib/active_admin/inputs/filters/date_range_input.rb

@@ -7,28 +7,41 @@ module ActiveAdmin
         def to_html
           input_wrapping do
             [ label_html,
-              builder.text_field(gt_input_name, input_html_options(gt_input_name)),
-              template.content_tag(:span, "-", class: "seperator"),
-              builder.text_field(lt_input_name, input_html_options(lt_input_name)),
+              builder.text_field(gt_input_name, input_html_options(gt_input_name, gt_input_placeholder)),
+              builder.text_field(lt_input_name, input_html_options(lt_input_name, lt_input_placeholder)),
             ].join("\n").html_safe
           end
         end
 
         def gt_input_name
-          "#{method}_gteq_date"
+          column && column.type == :date ? "#{method}_gteq" : "#{method}_gteq_datetime"
         end
         alias :input_name :gt_input_name
 
         def lt_input_name
-          "#{method}_lteq_date"
+          column && column.type == :date ? "#{method}_lteq" : "#{method}_lteq_datetime"
         end
 
-        def input_html_options(input_name = gt_input_name)
-          current_value = @object.public_send input_name
+        def input_html_options(input_name = gt_input_name, placeholder = gt_input_placeholder)
+          current_value = begin
+            #cast value to date object before rendering input
+            @object.public_send(input_name).to_s.to_date
+          rescue
+            nil
+          end
           { size: 12,
             class: "datepicker",
             maxlength: 10,
-            value: current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "" }
+            placeholder: placeholder,
+            value: current_value ? current_value.strftime("%Y-%m-%d") : "" }
+        end
+
+        def gt_input_placeholder
+          I18n.t("active_admin.filters.predicates.from")
+        end
+
+        def lt_input_placeholder
+          I18n.t("active_admin.filters.predicates.to")
         end
       end
     end

data/lib/active_admin/inputs/filters/select_input.rb

@@ -15,7 +15,7 @@ module ActiveAdmin
             "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
           else
             name = method.to_s
-            name.concat '_id' if reflection
+            name.concat "_#{reflection.association_primary_key}" if reflection_searchable?
             name
           end
         end
@@ -45,8 +45,11 @@ module ActiveAdmin
         end
 
         def pluck_column
-          distinct = ActiveAdmin::Dependency.rails >= 4 ? :distinct : :uniq
-          klass.reorder("#{method} asc").public_send(distinct).pluck method
+          klass.reorder("#{method} asc").distinct.pluck method
+        end
+
+        def reflection_searchable?
+          reflection && !reflection.polymorphic?
         end
 
       end

data/lib/active_admin/inputs/filters/text_input.rb

@@ -0,0 +1,25 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class TextInput < ::Formtastic::Inputs::TextInput
+        include Base
+        include Base::SearchMethodSelect
+
+        def input_html_options
+          {
+            cols: builder.default_text_area_width,
+            rows: builder.default_text_area_height
+          }.merge(super)
+        end
+
+        def to_html
+          input_wrapping do
+            label_html <<
+            builder.text_area(method, input_html_options)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_admin/inputs.rb

@@ -9,6 +9,7 @@ module ActiveAdmin
 
       autoload :Base
       autoload :StringInput
+      autoload :TextInput
       autoload :DatePickerInput
       autoload :DateRangeInput
       autoload :NumericInput

data/lib/active_admin/localizers/resource_localizer.rb

@@ -0,0 +1,35 @@
+module ActiveAdmin
+  module Localizers
+    class ResourceLocalizer
+      class << self
+        def from_resource(resource_config)
+          new(resource_config.resource_name.i18n_key, resource_config.resource_label)
+        end
+
+        def translate(key, options)
+          new(options.delete(:model_name), options.delete(:model)).translate(key, options)
+        end
+        alias_method :t, :translate
+      end
+
+      def initialize(model_name, model = nil)
+        @model_name = model_name
+        @model = model || model_name.to_s.titleize
+      end
+
+      def translate(key, options = {})
+        scope = options.delete(:scope)
+        specific_key = array_to_key('resources', @model_name, scope, key)
+        defaults = [array_to_key(scope, key), key.to_s.titleize]
+        ::I18n.t specific_key, options.reverse_merge(model: @model, default: defaults, scope: 'active_admin')
+      end
+      alias_method :t, :translate
+
+      protected
+
+      def array_to_key(*arr)
+        arr.flatten.compact.join('.').to_sym
+      end
+    end
+  end
+end

data/lib/active_admin/localizers.rb

@@ -0,0 +1,11 @@
+require 'active_admin/localizers/resource_localizer'
+
+module ActiveAdmin
+  module Localizers
+    class << self
+      def resource(active_admin_config)
+        ResourceLocalizer.from_resource(active_admin_config)
+      end
+    end
+  end
+end