activeadmin 0.6.6 → 1.0.0.pre1

data/lib/active_admin/inputs/datepicker_input.rb

@@ -2,10 +2,19 @@ module ActiveAdmin
   module Inputs
     class DatepickerInput < ::Formtastic::Inputs::StringInput
       def input_html_options
-        options = super
-        options[:class] = [options[:class], "datepicker"].compact.join(' ')
-        options
+        super.tap do |options|
+          options[:class] = [options[:class], "datepicker"].compact.join(' ')
+          options[:data] ||= {}
+          options[:data].merge! datepicker_options
+        end
       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
     end
   end
 end

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

@@ -0,0 +1,42 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      module Base
+        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
+        end
+
+        def required?
+          false
+        end
+
+        # Can pass proc to filter label option
+        def label_from_options
+          res = super
+          res = res.call if res.is_a? Proc
+          res
+        end
+
+        def wrapper_html_options
+          { class: "filter_form_field filter_#{as}" }
+        end
+
+        # Override the standard finder to accept a proc
+        def collection_from_options
+          if options[:collection].is_a?(Proc)
+            template.instance_exec(&options[:collection])
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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 Ransack. For example:
+#
+#   class FilterNumericInput < ::Formtastic::Inputs::NumberInput
+#     include FilterBase
+#     include FilterBase::SearchMethodSelect
+#
+#     filter :equals, :greater_than, :less_than
+#   end
+#
+module ActiveAdmin
+  module Inputs
+    module Filters
+      module Base
+        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' unless seems_searchable?
+            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.public_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
+end

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

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class BooleanInput < ::Formtastic::Inputs::SelectInput
+        include Base
+
+        def input_name
+          return method if seems_searchable?
+
+          "#{method}_eq"
+        end
+
+        def input_html_options_name
+          "#{object_name}[#{input_name}]" # was "#{object_name}[#{association_primary_key}]"
+        end
+
+        # Provide the AA translation to the blank input field.
+        def include_blank
+          I18n.t 'active_admin.any' if super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class CheckBoxesInput < ::Formtastic::Inputs::CheckBoxesInput
+        include Base
+
+        def input_name
+          "#{object_name}[#{searchable_method_name}_in][]"
+        end
+
+        def selected_values
+          @object.public_send("#{searchable_method_name}_in") || []
+        end
+
+        def searchable_method_name
+          if searchable_has_many_through?
+            "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
+          else
+            association_primary_key || method
+          end
+        end
+
+        # Add whitespace before label
+        def choice_label(choice)
+          ' ' + super
+        end
+
+        # Don't wrap in UL tag
+        def choices_group_wrapping(&block)
+          template.capture(&block)
+        end
+
+        # Don't wrap in LI tag
+        def choice_wrapping(html_options, &block)
+          template.capture(&block)
+        end
+
+        # Don't render hidden fields
+        def hidden_field_for_all
+          ""
+        end
+
+        # Don't render hidden fields
+        def hidden_fields?
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class DateRangeInput < ::Formtastic::Inputs::StringInput
+        include Base
+
+        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)),
+            ].join("\n").html_safe
+          end
+        end
+
+        def gt_input_name
+          "#{method}_gteq"
+        end
+        alias :input_name :gt_input_name
+
+        def lt_input_name
+          "#{method}_lteq"
+        end
+
+        def input_html_options(input_name = gt_input_name)
+          current_value = @object.public_send input_name
+          { size: 12,
+            class: "datepicker",
+            max: 10,
+            value: current_value.respond_to?(:strftime) ? current_value.strftime("%Y-%m-%d") : "" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class NumericInput < ::Formtastic::Inputs::NumberInput
+        include Base
+        include Base::SearchMethodSelect
+
+        filter :equals, :greater_than, :less_than
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class SelectInput < ::Formtastic::Inputs::SelectInput
+        include Base
+
+        def input_name
+          return method if seems_searchable?
+
+          searchable_method_name.concat multiple? ? '_in' : '_eq'
+        end
+
+        def searchable_method_name
+          if searchable_has_many_through?
+            "#{reflection.through_reflection.name}_#{reflection.foreign_key}"
+          else
+            name = method.to_s
+            name.concat '_id' if reflection
+            name
+          end
+        end
+
+        # Provide the AA translation to the blank input field.
+        def include_blank
+          I18n.t 'active_admin.any' if super
+        end
+
+        def input_html_options_name
+          "#{object_name}[#{input_name}]" # was "#{object_name}[#{association_primary_key}]"
+        end
+
+        # Would normally return true for has_many and HABTM, which would subsequently
+        # cause the select field to be multi-select instead of a dropdown.
+        def multiple_by_association?
+          false
+        end
+
+        # Provides an efficient default lookup query if the attribute is a DB column.
+        def collection
+          if !options[:collection] && column
+            pluck_column
+          else
+            super
+          end
+        end
+
+        def pluck_column
+          klass.reorder("#{method} asc").uniq.pluck method
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class StringInput < ::Formtastic::Inputs::StringInput
+        include Base
+        include Base::SearchMethodSelect
+
+        filter :contains, :equals, :starts_with, :ends_with
+
+        # If the filter method includes a search condition, build a normal string search field.
+        # Else, build a search field with a companion dropdown to choose a search condition from.
+        def to_html
+          if seems_searchable?
+            input_wrapping do
+              label_html <<
+              builder.text_field(method, input_html_options)
+            end
+          else
+            super # SearchMethodSelect#to_html
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/active_admin/menu.rb

@@ -47,9 +47,9 @@ module ActiveAdmin
       #
       def add(options)
         item = if parent = options.delete(:parent)
-          (self[parent] || add(:label => parent)).add options
+          (self[parent] || add(label: parent)).add options
         else
-          _add options.merge :parent => self
+          _add options.merge parent: self
         end
 
         yield(item) if block_given?
@@ -91,8 +91,10 @@ module ActiveAdmin
 
       def normalize_id(id)
         case id
-        when String, Symbol
-          id.to_s.downcase.gsub ' ', '_'
+        when String, Symbol, ActiveModel::Name
+          id.to_s.downcase.tr ' ', '_'
+        when ActiveAdmin::Resource::Name
+          id.param_key
         else
           raise TypeError, "#{id.class} isn't supported as a Menu ID"
         end

data/lib/active_admin/menu_collection.rb

@@ -5,9 +5,6 @@ module ActiveAdmin
   # A MenuCollection stores multiple menus for any given namespace. Namespaces delegate
   # the addition of menu items to this class.
   class MenuCollection
-
-    NoMenuError = Class.new(KeyError)
-
     def initialize
       @menus = {}
       @build_callbacks = []
@@ -34,7 +31,7 @@ module ActiveAdmin
       build_menus!
 
       @menus[menu_name] or
-        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in availble menus: #{@menus.keys.join(", ")}"
+        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in available menus: #{@menus.keys.join(", ")}"
     end
 
     # Add callbacks that will be run when the menu is going to be built. This

data/lib/active_admin/namespace.rb

@@ -11,7 +11,7 @@ module ActiveAdmin
   #
   # For example:
   #
-  #   ActiveAdmin.register Post, :namespace => :admin
+  #   ActiveAdmin.register Post, namespace: :admin
   #
   # Will register the Post model into the "admin" namespace. This will namespace the
   # urls for the resource to "/admin/posts" and will set the controller to
@@ -19,7 +19,7 @@ module ActiveAdmin
   #
   # You can also register to the "root" namespace, which is to say no namespace at all.
   #
-  #   ActiveAdmin.register Post, :namespace => false
+  #   ActiveAdmin.register Post, namespace: false
   #
   # This will register the resource to an instantiated namespace called :root. The
   # resource will be accessible from "/posts" and the controller will be PostsController.
@@ -45,7 +45,7 @@ module ActiveAdmin
 
       # Register the resource
       register_resource_controller(config)
-      parse_registration_block(config, &block) if block_given?
+      parse_registration_block(config, resource_class, &block) if block_given?
       reset_menu!
 
       # Dispatch a registration event
@@ -96,7 +96,7 @@ module ActiveAdmin
     # Override from ActiveAdmin::Settings to inherit default attributes
     # from the application
     def read_default_setting(name)
-      application.send(name)
+      application.public_send name
     end
 
     def fetch_menu(name)
@@ -112,7 +112,7 @@ module ActiveAdmin
     # @param [Symbol] name The name of the menu. Default: :default
     # @param [Proc] block The block to be ran when the menu is built
     #
-    # @returns [void]
+    # @return [void]
     def build_menu(name = DEFAULT_MENU, &block)
       @menus.before_build do |menus|
         menus.menu name do |menu|
@@ -121,22 +121,34 @@ module ActiveAdmin
       end
     end
 
-    # Add the default logout button to the menu, using the ActiveAdmin configuration settings
+    # The default logout menu item
     #
     # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
-    # @param [Fixnum] priority Override the default priority of 100 to position the logout button where you want
+    # @param [Fixnum] priority The numeric priority for the order in which it appears
     # @param [Hash] html_options An options hash to pass along to link_to
     #
-    # @returns [void]
-    def add_logout_button_to_menu(menu, priority=100, html_options={})
+    def add_logout_button_to_menu(menu, priority = 20, html_options = {})
       if logout_link_path
-        logout_method = logout_link_method || :get
-        menu.add :id           => 'logout',
-                 :priority     => priority,
-                 :label        => proc{ I18n.t('active_admin.logout') },
-                 :html_options => html_options.reverse_merge(:method => logout_method),
-                 :url          => proc{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
-                 :if           => proc{ current_active_admin_user? }
+        html_options = html_options.reverse_merge(method: logout_link_method || :get)
+        menu.add id: 'logout', priority: priority, html_options: html_options,
+          label: ->{ I18n.t 'active_admin.logout' },
+          url:   ->{ render_or_call_method_or_proc_on self, active_admin_namespace.logout_link_path },
+          if:    :current_active_admin_user?
+      end
+    end
+
+    # The default user session menu item
+    #
+    # @param [ActiveAdmin::MenuItem] menu The menu to add the logout link to
+    # @param [Fixnum] priority The numeric priority for the order in which it appears
+    # @param [Hash] html_options An options hash to pass along to link_to
+    #
+    def add_current_user_to_menu(menu, priority = 10, html_options = {})
+      if current_user_method
+        menu.add id: 'current_user', priority: priority, html_options: html_options,
+          label: -> { display_name current_active_admin_user },
+          url:   -> { auto_url_for(current_active_admin_user) },
+          if:    :current_active_admin_user?
       end
     end
 
@@ -158,17 +170,12 @@ module ActiveAdmin
     def build_default_utility_nav
       return if @menus.exists? :utility_navigation
       @menus.menu :utility_navigation do |menu|
-        menu.add  :label  => proc{ display_name current_active_admin_user },
-                  :url    => proc{ url_for [active_admin_namespace.name, current_active_admin_user] rescue '#' },
-                  :id     => 'current_user',
-                  :if     => proc{ current_active_admin_user? }
-
+        add_current_user_to_menu menu
         add_logout_button_to_menu menu
       end
     end
 
-    # Either returns an existing Resource instance or builds a new
-    # one for the resource and options
+    # Either returns an existing Resource instance or builds a new one.
     def find_or_build_resource(resource_class, options)
       resources.add Resource.new(self, resource_class, options)
     end
@@ -177,6 +184,7 @@ module ActiveAdmin
       resources.add Page.new(self, name, options)
     end
 
+    # TODO: replace `eval` with `Class.new`
     def register_page_controller(config)
       eval "class ::#{config.controller_name} < ActiveAdmin::PageController; end"
       config.controller.active_admin_config = config
@@ -185,9 +193,8 @@ module ActiveAdmin
     def unload_resources!
       resources.each do |resource|
         parent = (module_name || 'Object').constantize
-        const_name = resource.controller_name.split('::').last
-        # Remove the const if its been defined
-        parent.send(:remove_const, const_name) if parent.const_defined?(const_name)
+        name   = resource.controller_name.split('::').last
+        parent.send(:remove_const, name) if parent.const_defined? name
 
         # Remove circular references
         resource.controller.active_admin_config = nil
@@ -200,16 +207,19 @@ module ActiveAdmin
 
     # Creates a ruby module to namespace all the classes in if required
     def register_module
-      eval "module ::#{module_name}; end"
+      unless Object.const_defined? module_name
+        Object.const_set module_name, Module.new
+      end
     end
 
+    # TODO replace `eval` with `Class.new`
     def register_resource_controller(config)
       eval "class ::#{config.controller_name} < ActiveAdmin::ResourceController; end"
       config.controller.active_admin_config = config
     end
 
-    def parse_registration_block(config, &block)
-      config.dsl = ResourceDSL.new(config)
+    def parse_registration_block(config, resource_class, &block)
+      config.dsl = ResourceDSL.new(config, resource_class)
       config.dsl.run_registration_block(&block)
     end
 
@@ -217,5 +227,21 @@ module ActiveAdmin
       PageDSL.new(config).run_registration_block(&block)
     end
 
+    class Store
+      include Enumerable
+      delegate :[], :[]=, :empty?, to: :@namespaces
+
+      def initialize
+        @namespaces = {}
+      end
+
+      def each(&block)
+        @namespaces.values.each(&block)
+      end
+
+      def names
+        @namespaces.keys
+      end
+    end
   end
 end