activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/filters/resource_extension.rb

@@ -1,6 +1,12 @@
 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(*)
@@ -11,9 +17,9 @@ module ActiveAdmin
       # Returns the filters for this resource. If filters are not enabled,
       # it will always return an empty array.
       #
-      # @return [Array] Filters that apply for this resource
+      # @return [Hash] Filters that apply for this resource
       def filters
-        filters_enabled? ? filter_lookup : []
+        filters_enabled? ? filter_lookup : {}
       end
 
       # Setter to enable / disable filters on this resource.
@@ -39,14 +45,11 @@ module ActiveAdmin
       # Remove a filter for this resource. If filters are not enabled, this method
       # will raise a RuntimeError
       #
-      # @param [Symbol] attribute The attribute to not filter on
-      def remove_filter(attribute)
-        unless filters_enabled?
-          raise RuntimeError, "Can't remove a filter when filters are disabled. Enable filters with 'config.filters = true'"
-        end
+      # @param [Symbol] attributes The attributes to not filter on
+      def remove_filter(*attributes)
+        raise Disabled unless filters_enabled?
 
-        @filters_to_remove ||= []
-        @filters_to_remove << attribute
+        attributes.each { |attribute| (@filters_to_remove ||= []) << attribute.to_sym }
       end
 
       # Add a filter for this resource. If filters are not enabled, this method
@@ -54,14 +57,11 @@ module ActiveAdmin
       #
       # @param [Symbol] attribute The attribute to filter on
       # @param [Hash] options The set of options that are passed through to
-      #                       metasearch for the field definition.
+      #                       ransack for the field definition.
       def add_filter(attribute, options = {})
-        unless filters_enabled?
-          raise RuntimeError, "Can't add a filter when filters are disabled. Enable filters with 'config.filters = true'"
-        end
+        raise Disabled unless filters_enabled?
 
-        @filters ||= []
-        @filters << options.merge({ :attribute => attribute })
+        (@filters ||= {})[attribute.to_sym] = options
       end
 
       # Reset the filters to use defaults
@@ -70,40 +70,49 @@ 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.
       def filter_lookup
-        filters = @filters.try(:dup) || []
-        filters.push *default_filters if filters.empty? || preserve_default_filters?
+        filters = @filters.try(:dup) || {}
 
-        if @filters_to_remove
-          @filters_to_remove.each do |attr|
-            filters.delete_if{ |f| f.fetch(:attribute) == attr }
+        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
-        default_association_filters + default_content_filters
+        default_association_filters + default_content_filters + custom_ransack_filters
+      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?(:reflections)
-          block = if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
-            proc{ |_,r| [r.options[:foreign_type], r.primary_key_name] }
-          else
-            proc{ |_,r| [r.foreign_type, r.foreign_key] }
-          end
+        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 }
 
-          poly, not_poly = resource_class.reflections.partition{ |_,r| r.macro == :belongs_to && r.options[:polymorphic] }
-          filters        = poly.map(&block).flatten + not_poly.map(&:first)
-          filters.collect{ |name| { :attribute => name.to_sym } }
+          filters = poly.map(&:foreign_type) + not_poly.map(&:name)
+          filters.map &:to_sym
         else
           []
         end
@@ -111,8 +120,8 @@ module ActiveAdmin
 
       # 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.collect{|c| { :attribute => c.name.to_sym } }
+        if resource_class.respond_to? :content_columns
+          resource_class.content_columns.map{ |c| c.name.to_sym }
         else
           []
         end
@@ -123,7 +132,7 @@ module ActiveAdmin
       end
 
       def filters_sidebar_section
-        ActiveAdmin::SidebarSection.new(:filters, :only => :index, :if => proc{ 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

data/lib/active_admin/form_builder.rb

@@ -1,201 +1,140 @@
-module ActiveAdmin
-  class FormBuilder < ::Formtastic::FormBuilder
-
-    attr_reader :form_buffers
-
-    def initialize(*args)
-      @form_buffers = ["".html_safe]
-      super
+# Provides an intuitive way to build has_many associated records in the same form.
+module Formtastic
+  module Inputs
+    module Base
+      def input_wrapping(&block)
+        html = super
+        template.concat(html) if template.output_buffer && template.assigns['has_many_block']
+        html
+      end
     end
+  end
+end
 
-    def inputs(*args, &block)
-      @use_form_buffer = block_given?
-      form_buffers.last << with_new_form_buffer{ super }
-    end
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::FormBuilder
+    self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
 
-    # If this `input` call is inside a `inputs` block, add the content
-    # to the form buffer. Else, return it directly.
-    def input(method, *args)
-      content = with_new_form_buffer{ super }
-      @use_form_buffer ? form_buffers.last << content : content
-    end
+    # 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
-      form_buffers.last << template.content_tag(:li, li_content, li_attrs)
+      template.content_tag(:li, li_content, li_attrs)
     end
 
-    def actions(*args, &block)
-      form_buffers.last << with_new_form_buffer do
-        block_given? ? super : super{ commit_action_with_cancel_link }
-      end
-    end
-
-    def action(*args)
-      form_buffers.last << with_new_form_buffer{ super }
-    end
+    attr_accessor :already_in_an_inputs_block
 
-    def commit_action_with_cancel_link
-      action(:submit)
-      cancel_link
+    def assoc_heading(assoc)
+      object.class.reflect_on_association(assoc).klass.model_name.
+        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
     end
 
-    def has_many(association, options = {}, &block)
-      options = { :for => association, :new_record => true }.merge(options)
-      options[:class] ||= ""
-      options[:class] << "inputs has_many_fields"
+    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)
 
-      # Add Delete Links
-      form_block = proc do |has_many_form|
-        # @see https://github.com/justinfrench/formtastic/blob/2.2.1/lib/formtastic/helpers/inputs_helper.rb#L373
-        contents = if block.arity == 1  # for backwards compatibility with REE & Ruby 1.8.x
-          block.call(has_many_form)
-        else
-          index = parent_child_index(options[:parent]) if options[:parent]
-          block.call(has_many_form, index)
-        end
-
-        if has_many_form.object.new_record?
-          contents += template.content_tag(:li, :class => 'has_many_delete') do
-            template.link_to I18n.t('active_admin.has_many_delete'), "#", :onclick => "$(this).closest('.has_many_fields').remove(); return false;", :class => "button"
-          end
-        elsif options[:allow_destroy]
-          has_many_form.input :_destroy, :as => :boolean, :wrapper_html => {:class => "has_many_remove"},
-                                                          :label => I18n.t('active_admin.has_many_remove')
+      if sortable_column
+        options[:for] = [assoc, sorted_children(assoc, sortable_column)]
+      end
 
+      html = "".html_safe
+      unless builder_options.key?(:heading) && !builder_options[:heading]
+        html << template.content_tag(:h3) do
+          builder_options[:heading] || assoc_heading(assoc)
         end
-
-        contents
       end
 
-      form_buffers.last << with_new_form_buffer do
-        template.content_tag :div, :class => "has_many #{association}" do
-          # Allow customization of the nested form heading
-          unless options.key?(:heading) && !options[:heading]
-            form_heading = options[:heading] ||
-              object.class.reflect_on_association(association).klass.model_name.human(:count => 1.1)
-            form_buffers.last << template.content_tag(:h3, form_heading)
-          end
-
-          inputs options, &form_block
+      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) }
 
-          js = options[:new_record] ? js_for_has_many(association, form_block, template) : ""
-          form_buffers.last << js.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
-    end
 
-    def semantic_errors(*args)
-      form_buffers.last << with_new_form_buffer{ super }
+      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
     end
 
-    # These methods are deprecated and removed from Formtastic, however are
-    # supported here to help with transition.
-    module DeprecatedMethods
-
-      # Formtastic has depreciated #commit_button in favor of #action(:submit)
-      def commit_button(*args)
-        ::ActiveSupport::Deprecation.warn("f.commit_button is deprecated in favour of f.action(:submit)")
+    protected
 
-        options = args.extract_options!
-        if String === args.first
-          options[:label] = args.first unless options.has_key?(:label)
+    def has_many_actions(has_many_form, builder_options, contents)
+      if has_many_form.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
-
-        action(:submit, options)
+      elsif builder_options[:allow_destroy]
+        has_many_form.input(:_destroy, as: :boolean,
+                            wrapper_html: {class: 'has_many_delete'},
+                            label: I18n.t('active_admin.has_many_delete'))
       end
 
-      def commit_button_with_cancel_link
-        # Formtastic has depreciated #buttons in favor of #actions
-        ::ActiveSupport::Deprecation.warn("f.commit_button_with_cancel_link is deprecated in favour of f.commit_action_with_cancel_link")
+      if builder_options[:sortable]
+        has_many_form.input builder_options[:sortable], as: :hidden
 
-        commit_action_with_cancel_link
-      end
-
-      # The buttons method always needs to be wrapped in a new buffer
-      def buttons(*args, &block)
-        # Formtastic has depreciated #buttons in favor of #actions
-        ::ActiveSupport::Deprecation.warn("f.buttons is deprecated in favour of f.actions")
-
-        actions args, &block
+        contents << template.content_tag(:li, class: 'handle') do
+          Iconic.icon :move_vertical
+        end
       end
 
+      contents
     end
-    include DeprecatedMethods
-
-    protected
 
-    def active_admin_input_class_name(as)
-      "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
-    end
-
-    # Overrides Formtastic's version to include ActiveAdmin::Inputs::*
-    def input_class_with_const_defined(as)
-      input_class_name = custom_input_class_name(as)
-
-      if ::Object.const_defined?(input_class_name)
-        input_class_name.constantize
-      elsif ActiveAdmin::Inputs.const_defined?(input_class_name)
-        active_admin_input_class_name(as).constantize
-      elsif Formtastic::Inputs.const_defined?(input_class_name)
-        standard_input_class_name(as).constantize
-      else
-        raise Formtastic::UnknownInputError, "Unable to find input class #{input_class_name}"
+    def sorted_children(assoc, column)
+      object.public_send(assoc).sort_by do |o|
+        attribute = o.public_send column
+        [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
       end
     end
 
-    # use auto-loading in development environment
-    def input_class_by_trying(as)
-      begin
-        custom_input_class_name(as).constantize
-      rescue NameError
-        begin
-          active_admin_input_class_name(as).constantize
-        rescue NameError
-          standard_input_class_name(as).constantize
-        end
-      end
-    rescue NameError
-      raise Formtastic::UnknownInputError, "Unable to find input class for #{as}"
-    end
+    private
 
-    # This method calls the block it's passed (in our case, the `f.inputs` block)
-    # and wraps the resulting HTML in a fieldset. If your block doesn't have a
-    # valid return value but it was otherwise built correctly, we instead use
-    # the most recent part of the Active Admin form buffer.
-    def field_set_and_list_wrapping(*args, &block)
-      block_given? ? super{
-        (val = yield).is_a?(String) ? val : form_buffers.last
-      } : super
-    end
+    def without_wrapper
+      is_being_wrapped = @already_in_an_inputs_block
+      @already_in_an_inputs_block = false
 
-    private
+      html = yield
 
-    def with_new_form_buffer
-      form_buffers << ''.html_safe
-      return_value = (yield || '').html_safe
-      form_buffers.pop
-      return_value
+      @already_in_an_inputs_block = is_being_wrapped
+      html
     end
 
     # Capture the ADD JS
-    def js_for_has_many(association, form_block, template)
-      assoc_reflection = object.class.reflect_on_association(association)
+    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.upcase.split(' ').join('_')}_RECORD"
+      placeholder      = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
       opts = {
-        :for         => [association, assoc_reflection.klass.new],
-        :class       => "inputs has_many_fields",
-        :for_options => { :child_index => placeholder }
+        for: [assoc, assoc_reflection.klass.new],
+        class: class_string,
+        for_options: { child_index: placeholder }
       }
-      js = with_new_form_buffer{ inputs_for_nested_attributes opts, &form_block }
-      js = template.escape_javascript js
+      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)
 
-      onclick = "$(this).before('#{js}'.replace(/#{placeholder}/g, new Date().getTime())); return false;"
-      text    = I18n.t 'active_admin.has_many_new', :model => assoc_name.human
-
-      template.link_to(text, "#", :onclick => onclick, :class => "button").html_safe
+      template.link_to text, '#', class: "button has_many_add", data: {
+        html: CGI.escapeHTML(html).html_safe, placeholder: placeholder
+      }
     end
 
   end

data/lib/active_admin/helpers/collection.rb

@@ -1,22 +1,16 @@
 module ActiveAdmin
   module Helpers
     module Collection
-      # Works around this issue: https://github.com/rails/rails/issues/7121
-      #
-      # GROUP BY + COUNT drops SELECT statement. This leads to SQL error when
-      # the ORDER statement mentions a column defined in the SELECT statement.
-      #
-      # We remove the ORDER statement to work around this issue.
-      def collection_size(collection=collection())
-        size = collection.reorder("").count
-        # when GROUP BY is used, AR returns Hash instead of Fixnum for .size
-        size = size.size if size.kind_of?(Hash)
+      # 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)
+        c = c.except :select, :order
 
-        size
+        c.group_values.present? ? c.count.count : c.count
       end
 
-      def collection_is_empty?(collection=collection())
-        collection_size(collection) == 0
+      def collection_is_empty?(c = collection)
+        collection_size(c) == 0
       end
     end
   end