activeadmin 0.6.0 → 0.6.1

data/lib/active_admin/filters/formtastic_addons.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module Filters
+    module FormtasticAddons
+
+      #
+      # The below are Formtastic overrides to use `base` instead of `class` for MetaSearch.
+      #
+
+      # Returns the default label for a given attribute. Uses ActiveModel I18n if available.
+      def humanized_method_name
+        if object.base.respond_to?(:human_attribute_name)
+          object.base.human_attribute_name(method)
+        else
+          method.to_s.send(builder.label_str_method)
+        end
+      end
+
+      # Returns the association reflection for the method if it exists
+      def reflection_for(method)
+        @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
+      end
+
+      # Returns the column for an attribute on the object being searched if it exists.
+      def column_for(method)
+        @object.base.columns_hash[method.to_s] if @object.base.respond_to?(:columns_hash)
+      end
+
+      #
+      # The below are custom methods that Formtastic does not provide.
+      #
+
+      def foreign_key?(method)
+        @object.base.reflections.select{ |_,r| r.macro == :belongs_to }.values
+          .map(&:foreign_key).include? method.to_s
+      end
+
+      def polymorphic_foreign_type?(method)
+        type = Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0 ? proc{ |r| r.options[:foreign_type] } : :foreign_type
+        @object.base.reflections.values.select{ |r| r.macro == :belongs_to && r.options[:polymorphic] }
+          .map(&type).include? method.to_s
+      end
+
+    end
+  end
+end

data/lib/active_admin/filters/resource_extension.rb

@@ -96,7 +96,15 @@ module ActiveAdmin
       # Returns a default set of filters for the associations
       def default_association_filters
         if resource_class.respond_to?(:reflections)
-          resource_class.reflections.collect{|name, r| { :attribute => name }}
+          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
+
+          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 } }
         else
           []
         end

data/lib/active_admin/form_builder.rb

@@ -9,7 +9,7 @@ module ActiveAdmin
     end
 
     def inputs(*args, &block)
-      @inputs_with_block = block_given?
+      @use_form_buffer = block_given?
       form_buffers.last << with_new_form_buffer{ super }
     end
 
@@ -17,7 +17,7 @@ module ActiveAdmin
     # to the form buffer. Else, return it directly.
     def input(method, *args)
       content = with_new_form_buffer{ super }
-      @inputs_with_block ? form_buffers.last << content : content
+      @use_form_buffer ? form_buffers.last << content : content
     end
 
     def cancel_link(url = {:action => "index"}, html_options = {}, li_attrs = {})
@@ -42,7 +42,7 @@ module ActiveAdmin
     end
 
     def has_many(association, options = {}, &block)
-      options = { :for => association }.merge(options)
+      options = { :for => association, :new_record => true }.merge(options)
       options[:class] ||= ""
       options[:class] << "inputs has_many_fields"
 
@@ -57,9 +57,13 @@ module ActiveAdmin
         end
 
         if has_many_form.object.new_record?
-          contents += template.content_tag(:li) do
+          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')
+
         end
 
         contents
@@ -67,10 +71,17 @@ module ActiveAdmin
 
       form_buffers.last << with_new_form_buffer do
         template.content_tag :div, :class => "has_many #{association}" do
-          form_buffers.last << template.content_tag(:h3, object.class.reflect_on_association(association).klass.model_name.human(:count => 1.1))
+          # 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
 
-          form_buffers.last << js_for_has_many(association, form_block, template)
+          js = options[:new_record] ? js_for_has_many(association, form_block, template) : ""
+          form_buffers.last << js.html_safe
         end
       end
     end
@@ -119,7 +130,7 @@ module ActiveAdmin
       "ActiveAdmin::Inputs::#{as.to_s.camelize}Input"
     end
 
-    # prevent exceptions in production environment for better performance
+    # Overrides Formtastic's version to include ActiveAdmin::Inputs::*
     def input_class_with_const_defined(as)
       input_class_name = custom_input_class_name(as)
 
@@ -130,33 +141,33 @@ module ActiveAdmin
       elsif Formtastic::Inputs.const_defined?(input_class_name)
         standard_input_class_name(as).constantize
       else
-        raise Formtastic::UnknownInputError
+        raise Formtastic::UnknownInputError, "Unable to find input class #{input_class_name}"
       end
     end
 
     # use auto-loading in development environment
     def input_class_by_trying(as)
       begin
+        custom_input_class_name(as).constantize
+      rescue NameError
         begin
-          custom_input_class_name(as).constantize
+          active_admin_input_class_name(as).constantize
         rescue NameError
-          begin
-            active_admin_input_class_name(as).constantize
-          rescue NameError
-            standard_input_class_name(as).constantize
-          end
+          standard_input_class_name(as).constantize
         end
       end
     rescue NameError
-      raise Formtastic::UnknownInputError
+      raise Formtastic::UnknownInputError, "Unable to find input class for #{as}"
     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 happens to return
-    # nil (but it otherwise built the form correctly), the below override passes
+    # 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{ yield || form_buffers.last } : super
+      block_given? ? super{
+        (val = yield).is_a?(String) ? val : form_buffers.last
+      } : super
     end
 
     private
@@ -172,7 +183,7 @@ module ActiveAdmin
     def js_for_has_many(association, form_block, template)
       assoc_reflection = object.class.reflect_on_association(association)
       assoc_name       = assoc_reflection.klass.model_name
-      placeholder      = "NEW_#{assoc_name.upcase.split(' ').join('_')}_RECORD"
+      placeholder      = "NEW_#{assoc_name.to_s.upcase.split(' ').join('_')}_RECORD"
       opts = {
         :for         => [association, assoc_reflection.klass.new],
         :class       => "inputs has_many_fields",

data/lib/active_admin/helpers/optional_display.rb

@@ -14,26 +14,24 @@ module ActiveAdmin
   # to ensure that the display options are setup correctly
 
   module OptionalDisplay
-    def display_on?(action, render_context = nil)
-      return false if @options[:only] && !@options[:only].include?(action.to_sym)
+    def display_on?(action, render_context = self)
+      return false if @options[:only]   && !@options[:only].include?(action.to_sym)
       return false if @options[:except] && @options[:except].include?(action.to_sym)
-      if @options[:if]
-        symbol_or_proc = @options[:if]
-        return case symbol_or_proc
-        when Symbol, String
-          render_context ? render_context.send(symbol_or_proc) : self.send(symbol_or_proc)
-        when Proc
-          render_context ? render_context.instance_exec(&symbol_or_proc) : instance_exec(&symbol_or_proc)
-        else symbol_or_proc
-        end
+
+      case condition = @options[:if]
+      when Symbol, String
+        render_context.send condition
+      when Proc
+        render_context.instance_exec &condition
+      else
+        true
       end
-      true
     end
 
     private
 
     def normalize_display_options!
-      @options[:only] = Array(@options[:only]) if @options[:only]
+      @options[:only]   = Array(@options[:only])   if @options[:only]
       @options[:except] = Array(@options[:except]) if @options[:except]
     end
   end

data/lib/active_admin/helpers/settings.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 module ActiveAdmin
 
   # Adds a class method to a class to create settings with default values.
@@ -18,7 +16,10 @@ module ActiveAdmin
   #   conf.site_title #=> "Override Default"
   #
   module Settings
-    extend ActiveSupport::Concern
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
 
     def read_default_setting(name)
       default_settings[name]
@@ -34,10 +35,9 @@ module ActiveAdmin
 
       def setting(name, default)
         default_settings[name] = default
-        attr_accessor(name)
+        attr_writer name
 
-        # Create an accessor that grabs from the defaults
-        # if @name has not been set yet
+        # 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}
@@ -50,10 +50,10 @@ module ActiveAdmin
       end
 
       def deprecated_setting(name, default, message = nil)
-        message = message || "The #{name} setting is deprecated and will be removed."
         setting(name, default)
 
-        ActiveAdmin::Deprecation.deprecate self, name, message
+        message ||= "The #{name} setting is deprecated and will be removed."
+        ActiveAdmin::Deprecation.deprecate self,     name,    message
         ActiveAdmin::Deprecation.deprecate self, :"#{name}=", message
       end
 
@@ -62,5 +62,47 @@ module ActiveAdmin
       end
 
     end
+
+
+    # Allows you to define child classes that should receive the same
+    # settings, as well as the same default values.
+    #
+    # Example from the codebase:
+    #
+    #   class Application
+    #     include Settings
+    #     include Settings::Inheritance
+    #
+    #     settings_inherited_by :Namespace
+    #
+    #     inheritable_setting :root_to, 'dashboard#index'
+    #   end
+    #
+    module Inheritance
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def settings_inherited_by(heir)
+          (@setting_heirs ||= []) << heir
+          heir.send :include, ActiveAdmin::Settings
+        end
+
+        def inheritable_setting(name, default)
+          setting name, default
+          @setting_heirs.each{ |c| c.setting name, default }
+        end
+
+        def deprecated_inheritable_setting(name, default)
+          deprecated_setting name, default
+          @setting_heirs.each{ |c| c.deprecated_setting name, default }
+        end
+
+      end
+    end
+
   end
 end

data/lib/active_admin/inputs/filter_base.rb

@@ -2,12 +2,13 @@ module ActiveAdmin
   module Inputs
     module FilterBase
       include ::Formtastic::Inputs::Base
+      include ::ActiveAdmin::Filters::FormtasticAddons
+
+      extend ::ActiveSupport::Autoload
+      autoload :SearchMethodSelect
 
       def input_wrapping(&block)
-        template.content_tag(:div,
-          template.capture(&block),
-          wrapper_html_options
-        )
+        template.content_tag :div, template.capture(&block), wrapper_html_options
       end
 
       def required?
@@ -27,20 +28,6 @@ module ActiveAdmin
         end
       end
 
-      # Returns the default label for a given attribute
-      # Will use ActiveModel I18n if possible
-      def humanized_method_name
-        if object.base.respond_to?(:human_attribute_name)
-          object.base.human_attribute_name(method)
-        else
-          method.to_s.send(builder.label_str_method)
-        end
-      end
-
-      # Returns the association reflection for the method if it exists
-      def reflection_for(method)
-        @object.base.reflect_on_association(method) if @object.base.respond_to?(:reflect_on_association)
-      end
     end
   end
 end

data/lib/active_admin/inputs/filter_base/search_method_select.rb

@@ -0,0 +1,73 @@
+# This is a common set of Formtastic overrides needed to build a filter form
+# that lets you select from a set of search methods for a given attribute.
+#
+# Your class must declare available filters for this module to work.
+# Those filters must be recognizable by Metasearch. For example:
+#
+#   class FilterNumericInput < ::Formtastic::Inputs::NumberInput
+#     include FilterBase
+#     include FilterBase::SearchMethodSelect
+#
+#     filter :equals, :greater_than, :less_than
+#   end
+#
+module ActiveAdmin
+  module Inputs
+    module FilterBase
+      module SearchMethodSelect
+
+        def self.included(base)
+          base.extend ClassMethods
+        end
+
+        module ClassMethods
+          attr_reader :filters
+
+          def filter(*filters)
+            (@filters ||= []).push *filters
+          end
+        end
+
+        def wrapper_html_options
+          opts = super
+          (opts[:class] ||= '') << ' select_and_search'
+          opts
+        end
+
+        def to_html
+          input_wrapping do
+            label_html  << # your label
+            select_html << # the dropdown that holds the available search methods
+            input_html     # your input field
+          end
+        end
+
+        def input_html
+          builder.text_field current_filter, input_html_options
+        end
+
+        def select_html
+          template.select_tag '', template.options_for_select(filter_options, current_filter)
+        end
+
+        def filters
+          options[:filters] || self.class.filters
+        end
+
+        def current_filter
+          @current_filter ||= begin
+            methods = filters.map{ |f| "#{method}_#{f}" }
+            methods.detect{ |m| @object.send m } || methods.first
+          end
+        end
+
+        def filter_options
+          filters.collect do |filter|
+            [I18n.t("active_admin.filters.predicates.#{filter}"), "#{method}_#{filter}"]
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_admin/inputs/filter_boolean_input.rb

@@ -4,35 +4,27 @@ module ActiveAdmin
       include FilterBase
 
       def to_html
-        input_wrapping do 
+        input_wrapping do
           [ label_html,
             check_box_html
           ].join("\n").html_safe
         end
       end
 
-      def check_box_html
-        template.check_box_tag("#{object_name}[#{method}]", checked_value, checked?, input_html_options)
-      end
-
       def search_method
-        method.to_s.match(metasearch_conditions) ? method : "#{method}_eq"
+        method.to_s.match(search_conditions) ? method : "#{method}_eq"
       end
 
       def checked?
-        if defined? ActionView::Helpers::InstanceTag
-          object && ActionView::Helpers::InstanceTag.check_box_checked?(object.send(search_method), checked_value)
-        else
-          object && boolean_checked?(object.send(search_method), checked_value)
-        end
+        object && boolean_checked?(object.send(search_method), checked_value)
       end
 
       def input_html_options
-        { :name => "q[#{search_method}]" }
+        { :name => "q[#{ search_method }]" }
       end
 
-      def metasearch_conditions
-        /(is_true|is_false|is_present|is_blank|is_null|is_not_null)$/
+      def search_conditions
+        /(is_true|is_false|is_present|is_blank|is_null|is_not_null)\z/
       end
 
     end