aa-rails4 0.6.0

data/lib/active_admin/inputs.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :DatepickerInput
+
+    autoload :FilterBase
+    autoload :FilterStringInput
+    autoload :FilterDateRangeInput
+    autoload :FilterNumericInput
+    autoload :FilterSelectInput
+    autoload :FilterCheckBoxesInput
+    autoload :FilterBooleanInput
+  end
+end

data/lib/active_admin/inputs/datepicker_input.rb

@@ -0,0 +1,11 @@
+module ActiveAdmin
+  module Inputs
+    class DatepickerInput < ::Formtastic::Inputs::StringInput
+      def input_html_options
+        options = super
+        options[:class] = [options[:class], "datepicker"].compact.join(' ')
+        options
+      end
+    end
+  end
+end

data/lib/active_admin/inputs/filter_base.rb

@@ -0,0 +1,33 @@
+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
+      end
+
+      def required?
+        false
+      end
+
+      def wrapper_html_options
+        { :class => "filter_form_field #{as}" }
+      end
+
+      # Override the standard finder to accept a proc
+      def collection_from_options
+        if options[:collection].is_a?(Proc)
+          template.instance_eval(&options[:collection])
+        else
+          super
+        end
+      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

@@ -0,0 +1,32 @@
+module ActiveAdmin
+  module Inputs
+    class FilterBooleanInput < ::Formtastic::Inputs::BooleanInput
+      include FilterBase
+
+      def to_html
+        input_wrapping do
+          [ label_html,
+            check_box_html
+          ].join("\n").html_safe
+        end
+      end
+
+      def search_method
+        method =~ search_conditions ? method : "#{method}_eq"
+      end
+
+      def checked?
+        object && boolean_checked?(object.send(search_method), checked_value)
+      end
+
+      def input_html_options
+        { :name => "q[#{ search_method }]" }
+      end
+
+      def search_conditions
+        /_(true|false|present|blank|null|not_null)\z/
+      end
+
+    end
+  end
+end

data/lib/active_admin/inputs/filter_check_boxes_input.rb

@@ -0,0 +1,40 @@
+module ActiveAdmin
+  module Inputs
+    class FilterCheckBoxesInput < ::Formtastic::Inputs::CheckBoxesInput
+      include FilterBase
+
+      def input_name
+        "#{object_name}[#{association_primary_key || method}_in][]"
+      end
+
+      def selected_values
+        @object.send("#{association_primary_key || method}_in") || []
+      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

data/lib/active_admin/inputs/filter_date_range_input.rb

@@ -0,0 +1,34 @@
+module ActiveAdmin
+  module Inputs
+    class FilterDateRangeInput < ::Formtastic::Inputs::StringInput
+      include FilterBase
+
+      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.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

data/lib/active_admin/inputs/filter_numeric_input.rb

@@ -0,0 +1,10 @@
+module ActiveAdmin
+  module Inputs
+    class FilterNumericInput < ::Formtastic::Inputs::NumberInput
+      include FilterBase
+      include FilterBase::SearchMethodSelect
+
+      filter :equals, :greater_than, :less_than
+    end
+  end
+end

data/lib/active_admin/inputs/filter_select_input.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module Inputs
+    class FilterSelectInput < ::Formtastic::Inputs::SelectInput
+      include FilterBase
+
+      # When it's a HABTM or has_many association, Formtastic builds "object_ids".
+      # That doesn't fit our scenario, so we override it here.
+      def input_name
+        name = method.to_s
+        name.concat '_id' if reflection
+        name.concat multiple? ? '_in' : '_eq'
+      end
+
+      # Include the "Any" option if it's a dropdown, but not if it's a multi-select.
+      def input_options
+        super.merge :include_blank => multiple? ? false : I18n.t('active_admin.any')
+      end
+
+      # was "#{object_name}[#{association_primary_key}]"
+      def input_html_options_name
+        "#{object_name}[#{input_name}]"
+      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

data/lib/active_admin/inputs/filter_string_input.rb

@@ -0,0 +1,24 @@
+module ActiveAdmin
+  module Inputs
+    class FilterStringInput < ::Formtastic::Inputs::StringInput
+      include FilterBase
+      include FilterBase::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 method.to_s =~ /_(#{filters.join('|')})\z/
+          input_wrapping do
+            label_html <<
+            builder.text_field(method, input_html_options)
+          end
+        else
+          super # SearchMethodSelect#to_html
+        end
+      end
+
+    end
+  end
+end

data/lib/active_admin/menu.rb

@@ -0,0 +1,107 @@
+module ActiveAdmin
+
+  # Each Namespace builds up it's own menu as the global navigation
+  #
+  # To build a new menu:
+  #
+  #   menu = Menu.new do |m|
+  #     m.add label: 'Dashboard', url: '/'
+  #     m.add label: 'Users',     url: '/users'
+  #   end
+  #
+  # If you're interested in configuring a menu item, take a look at the
+  # options available in `ActiveAdmin::MenuItem`
+  #
+  class Menu
+
+    def initialize
+      super # MenuNode
+      yield(self) if block_given?
+    end
+
+    module MenuNode
+      def initialize
+        @children = {}
+      end
+
+      def [](id)
+        @children[normalize_id(id)]
+      end
+      def []=(id, child)
+        @children[normalize_id(id)] = child
+      end
+
+      # Recursively builds any given menu items. There are two syntaxes supported,
+      # as shown in the below examples. Both create an identical menu structure.
+      #
+      # Example 1:
+      #   menu = Menu.new
+      #   menu.add label: 'Dashboard' do |dash|
+      #     dash.add label: 'My Child Dashboard'
+      #   end
+      #
+      # Example 2:
+      #   menu = Menu.new
+      #   menu.add label:  'Dashboard'
+      #   menu.add parent: 'Dashboard', label: 'My Child Dashboard'
+      #
+      def add(options)
+        item = if parent = options.delete(:parent)
+          (self[parent] || add(:label => parent)).add options
+        else
+          _add options.merge :parent => self
+        end
+
+        yield(item) if block_given?
+
+        item
+      end
+
+      # Whether any children match the given item.
+      def include?(item)
+        @children.values.include? item
+      end
+
+      # Used in the UI to visually distinguish which menu item is selected.
+      def current?(item)
+        self == item || include?(item)
+      end
+
+      # Returns sorted array of menu items that should be displayed in this context.
+      # Sorts by priority first, then alphabetically by label if needed.
+      def items(context = nil)
+        @children.values.select{ |i| i.display?(context) }.sort do |a,b|
+          result = a.priority       <=> b.priority
+          result = a.label(context) <=> b.label(context) if result == 0
+          result
+        end
+      end
+
+      attr_reader :children
+      private
+      attr_writer :children
+
+      # The method that actually adds new menu items. Called by the public method.
+      # If this ID is already taken, transfer the children of the existing item to the new item.
+      def _add(options)
+        item = ActiveAdmin::MenuItem.new(options)
+        item.send :children=, self[item.id].children if self[item.id]
+        self[item.id] = item
+      end
+
+      def normalize_id(id)
+        case id
+        when String, Symbol, ActiveModel::Name
+          id.to_s.downcase.gsub ' ', '_'
+        when ActiveAdmin::Resource::Name
+          id.param_key
+        else
+          raise TypeError, "#{id.class} isn't supported as a Menu ID"
+        end
+      end
+    end
+
+    include MenuNode
+
+  end
+end

data/lib/active_admin/menu_collection.rb

@@ -0,0 +1,96 @@
+module ActiveAdmin
+
+  DEFAULT_MENU = :default
+
+  # 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 = []
+      @built = false
+    end
+
+    # Add a new menu item to a menu in the collection
+    def add(menu_name, menu_item_options = {})
+      menu = find_or_create(menu_name)
+
+      menu.add menu_item_options
+    end
+
+    def clear!
+      @menus = {}
+      @built = false
+    end
+
+    def exists?(menu_name)
+      @menus.keys.include? menu_name
+    end
+
+    def fetch(menu_name)
+      build_menus!
+
+      @menus[menu_name] or
+        raise NoMenuError, "No menu by the name of #{menu_name.inspect} in availble menus: #{@menus.keys.join(", ")}"
+    end
+
+    # Add callbacks that will be run when the menu is going to be built. This
+    # helps use with reloading and allows configurations to add items to menus.
+    #
+    # @param [Proc] block A block which will be ran when the menu is built. The
+    #                   will have the menu collection yielded.
+    def on_build(&block)
+      @build_callbacks << block
+    end
+
+    # Add callbacks that will be run before the menu is built
+    def before_build(&block)
+      @build_callbacks.unshift(block)
+    end
+
+    def menu(menu_name)
+      menu = find_or_create(menu_name)
+
+      yield(menu) if block_given?
+
+      menu
+    end
+
+    private
+
+    def built?
+      @built
+    end
+
+    def build_menus!
+      return if built?
+
+      build_default_menu
+      run_on_build_callbacks
+
+      @built = true
+    end
+
+    def run_on_build_callbacks
+      @build_callbacks.each do |callback|
+        callback.call(self)
+      end
+    end
+
+    def build_default_menu
+      find_or_create DEFAULT_MENU
+    end
+
+    def find_or_create(menu_name)
+      menu_name ||= DEFAULT_MENU
+      @menus[menu_name] ||= ActiveAdmin::Menu.new
+    end
+
+
+
+  end
+
+end