yousty-activeadmin 1.0.4.pre → 1.0.5.pre

data/lib/active_admin/filters/resource_extension.rb

@@ -17,10 +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
-        return [] unless filters_enabled?
-        filter_lookup
+        filters_enabled? ? filter_lookup : {}
       end
 
       # Setter to enable / disable filters on this resource.
@@ -46,11 +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)
+      # @param [Symbol] attributes The attributes to not filter on
+      def remove_filter(*attributes)
         raise Disabled unless filters_enabled?
 
-        (@filters_to_remove ||= []) << attribute.to_sym
+        attributes.each { |attribute| (@filters_to_remove ||= []) << attribute.to_sym }
       end
 
       # Add a filter for this resource. If filters are not enabled, this method
@@ -76,7 +75,7 @@ module ActiveAdmin
       # 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(:deep_dup) || {}
+        filters = @filters.try(:dup) || {}
 
         if filters.empty? || preserve_default_filters?
           default_filters.each do |f|
@@ -93,7 +92,15 @@ module ActiveAdmin
 
       # @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
@@ -101,7 +108,7 @@ module ActiveAdmin
         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 associations nested more than twice
+          # remove deeply nested associations
           not_poly.reject!{ |r| r.chain.length > 2 }
 
           filters = poly.map(&:foreign_type) + not_poly.map(&:name)

data/lib/active_admin/form_builder.rb

@@ -1,146 +1,135 @@
-# Note for posterity:
-#
-# Here we have two core customizations on top of Formtastic. First, this allows
-# you to build forms in the AA DSL without dealing with the HTML return value of
-# individual form methods (hence the +form_buffers+ object). Second, this provides
-# an intuitive way to build has_many associated records in the same form.
-#
-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(assoc, options = {}, &block)
-      options = {for: assoc, new_record: true}.merge options
-      options[:class] ||= ""
-      options[:class] << "inputs has_many_fields"
-
-      # Add Delete Links
-      form_block = proc do |has_many_form|
-        index    = parent_child_index options[:parent] if options[:parent]
-        contents = block.call has_many_form, index
-
-        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
-        elsif 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
-        contents
+      # 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)
+
+      if sortable_column
+        options[:for] = [assoc, sorted_children(assoc, sortable_column)]
       end
 
-      form_buffers.last << with_new_form_buffer do
-        template.content_tag :div, class: "has_many #{assoc}" do
-          unless options.key?(:heading) && !options[:heading]
-            form_buffers.last << template.content_tag(:h3) do
-              options[:heading] || object.class.reflect_on_association(assoc).klass.model_name.human(count: 1.1)
-            end
-          end
-
-          inputs options, &form_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
 
-          form_buffers.last << js_for_has_many(assoc, form_block, template, options[:new_record]) if options[:new_record]
+      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) }
+
+        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
 
     protected
 
-    def active_admin_input_class_name(as)
-      "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
-    end
+    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
+      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 input_class(as)
-      @input_classes_cache ||= {}
-      @input_classes_cache[as] ||= begin
-        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
+      if builder_options[:sortable]
+        has_many_form.input builder_options[:sortable], as: :hidden
+
+        contents << template.content_tag(:li, class: 'handle') do
+          Iconic.icon :move_vertical
         end
-      rescue NameError
-        raise Formtastic::UnknownInputError, "Unable to find input class for #{as}"
       end
+
+      contents
     end
 
-    # 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
+    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
 
     private
 
-    def with_new_form_buffer
-      form_buffers << ''.html_safe
-      return_value = (yield || '').html_safe
-      form_buffers.pop
-      return_value
+    def without_wrapper
+      is_being_wrapped = @already_in_an_inputs_block
+      @already_in_an_inputs_block = false
+
+      html = yield
+
+      @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)
+    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         => [assoc, 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 }
       }
-      html = with_new_form_buffer{ inputs_for_nested_attributes opts, &form_block }
+      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)
 
       template.link_to text, '#', class: "button has_many_add", data: {

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

data/lib/active_admin/helpers/i18n.rb

@@ -0,0 +1,7 @@
+module ActiveAdmin
+  module Helpers
+    module I18n
+      PLURAL_MANY_COUNT = 2.1
+    end
+  end
+end

data/lib/active_admin/helpers/optional_display.rb

@@ -5,10 +5,10 @@ module ActiveAdmin
   #
   # The options hash accepts:
   #
-  # :only => :index
-  # :only => [:index, :show]
-  # :except => :index
-  # :except => [:index, :show]
+  # only: :index
+  # only: [:index, :show]
+  # except: :index
+  # except: [:index, :show]
   #
   # call #normalize_display_options! after @options has been set
   # to ensure that the display options are setup correctly
@@ -20,7 +20,7 @@ module ActiveAdmin
 
       case condition = @options[:if]
       when Symbol, String
-        render_context.send condition
+        render_context.public_send condition
       when Proc
         render_context.instance_exec &condition
       else

data/lib/active_admin/helpers/scope_chain.rb

@@ -12,7 +12,7 @@ module ActiveAdmin
     #
     def scope_chain(scope, chain)
       if scope.scope_method
-        chain.send(scope.scope_method)
+        chain.public_send scope.scope_method
       elsif scope.scope_block
         instance_exec chain, &scope.scope_block
       else

data/lib/active_admin/helpers/settings.rb

@@ -37,16 +37,23 @@ module ActiveAdmin
         default_settings[name] = default
         attr_writer name
 
-        # Creates a reader that will grab the default if no value has been set.
-        class_eval <<-EOC, __FILE__, __LINE__ + 1
-          def #{name}
-            if instance_variable_defined? :@#{name}
-              @#{name}
-            else
-              read_default_setting(:#{name})
-            end
+        # Create an accessor that looks up the default value if none is set.
+        define_method name do
+          if instance_variable_defined? "@#{name}"
+            instance_variable_get "@#{name}"
+          else
+            read_default_setting name.to_sym
           end
-        EOC
+        end
+
+        define_method "#{name}?" do
+          value = public_send(name)
+          if value.is_a? Array
+            value.any?
+          else
+            value.present?
+          end
+        end
       end
 
       def deprecated_setting(name, default, message = nil)

data/lib/active_admin/iconic.rb

@@ -7,32 +7,33 @@ module ActiveAdmin
     @@default_color = "#5E6469"
     mattr_accessor :default_color
 
-    # Default width to use for icons
-    @@default_width = 15
-    mattr_accessor :default_width
-
-    # Default height to use for icons
-    @@default_height = 15
-    mattr_accessor :default_height
 
     # Render an icon:
-    #   Iconic.icon :loop
+    #   Iconic.icon :loop, width: 100, height: 100, color: "#5E6469"
+    #   Iconic.icon :loop, width: "1em", height: "1em", color: "#5E6469"
+    # NOTE: you can omit the dimensions if they are specified in css
     def self.icon(name, options = {})
       options = {
-        :color => default_color,
-        :width => default_width,
-        :height => default_height,
-        :id => ""
+        color: default_color,
+        id: ""
       }.merge(options)
 
-
       options[:style] = "fill:#{options[:color]};"
       options[:fill] = options.delete(:color)
 
+      css = options.delete(:css) || {}
+
+      # extract desired dimensions to be used as the wrapper's inline styles
       # Convert to strings representations of pixels
       [:width, :height].each do |key|
-        options[key] = "#{options[key]}px" unless options[key].is_a?(String)
+        value = options.delete key
+        css[key] ||= "#{value}px" unless value.blank? || value.is_a?(String)
       end
+      css_str = css.map {|k,v| "#{k}:#{v}"}.join(";")
+      css_str = "style=\"#{css_str}\"" if css_str.present?
+
+      # make the svg itself expand to its parent
+      options[:width] = options[:height] = "100%"
 
       template = ICONS[name.to_sym]
 
@@ -41,7 +42,8 @@ module ActiveAdmin
         options.each do |key, value|
           svg.gsub!("{#{key}}", value)
         end
-        "<span class=\"icon icon_#{name}\">#{svg}</span>".html_safe
+
+        "<span class=\"icon icon_#{name}\" #{css_str}>#{svg}</span>".html_safe
       else
         raise "Could not find the icon named #{name}"
       end