activeadmin-orac 1.0.0.pre4

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

@@ -0,0 +1,44 @@
+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
+          opts = super
+          (opts[:class] ||= '') << " filter_form_field filter_#{as}"
+          opts
+        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 NumericInput < ::Formtastic::Inputs::NumberInput
+#     include Base
+#     include Base::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_picker_input.rb

@@ -0,0 +1,13 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class DatePickerInput < ::Formtastic::Inputs::DatePickerInput
+        include Base
+
+        def input_html_options
+          super.merge(class: "datepicker")
+        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_date"
+        end
+        alias :input_name :gt_input_name
+
+        def lt_input_name
+          "#{method}_lteq_date"
+        end
+
+        def input_html_options(input_name = gt_input_name)
+          current_value = @object.public_send input_name
+          { size: 12,
+            class: "datepicker",
+            maxlength: 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,55 @@
+module ActiveAdmin
+  module Inputs
+    module Filters
+      class SelectInput < ::Formtastic::Inputs::SelectInput
+        include Base
+
+        def input_name
+          return method if seems_searchable?
+
+          searchable_method_name + (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
+          distinct = ActiveAdmin::Dependency.rails >= 4 ? :distinct : :uniq
+          klass.reorder("#{method} asc").public_send(distinct).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

@@ -0,0 +1,108 @@
+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.tr ' ', '_'
+        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