activeadmin-rb 1.4.0

data/lib/active_admin/helpers/collection.rb

@@ -0,0 +1,19 @@
+module ActiveAdmin
+  module Helpers
+    module Collection
+      # 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)
+        return c.count if c.is_a?(Array)
+
+        c = c.except :select, :order
+
+        c.group_values.present? ? c.count.count : c.count
+      end
+
+      def collection_is_empty?(c = collection)
+        collection_size(c) == 0
+      end
+    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

@@ -0,0 +1,38 @@
+module ActiveAdmin
+
+  # Shareable module to give a #display_on?(action) method
+  # which returns true or false depending on an options hash.
+  #
+  # The options hash accepts:
+  #
+  # 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
+
+  module OptionalDisplay
+    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)
+
+      case condition = @options[:if]
+      when Symbol, String
+        render_context.public_send condition
+      when Proc
+        render_context.instance_exec &condition
+      else
+        true
+      end
+    end
+
+    private
+
+    def normalize_display_options!
+      @options[:only]   = Array(@options[:only])   if @options[:only]
+      @options[:except] = Array(@options[:except]) if @options[:except]
+    end
+  end
+end

data/lib/active_admin/helpers/output_safety_helper.rb

@@ -0,0 +1,35 @@
+module ActiveAdmin
+  module OutputSafetyHelper
+    # Converts the array to a comma-separated sentence where the last element is
+    # joined by the connector word. This is the html_safe-aware version of
+    # ActiveSupport's {Array#to_sentence}[http://api.rubyonrails.org/classes/Array.html#method-i-to_sentence].
+    #
+    # Copied from Rails 5 to support Rails 4.
+    # https://github.com/rails/rails/blob/9c35bf2a6a27431c6aa283db781c19f61c5155be/actionview/lib/action_view/helpers/output_safety_helper.rb#L43
+    def to_sentence(array, options = {})
+      options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+
+      default_connectors = {
+        words_connector: ", ",
+        two_words_connector: " and ",
+        last_word_connector: ", and "
+      }
+      if defined?(::I18n)
+        i18n_connectors = ::I18n.translate(:'support.array', locale: options[:locale], default: {})
+        default_connectors.merge!(i18n_connectors)
+      end
+      options = default_connectors.merge!(options)
+
+      case array.length
+      when 0
+        "".html_safe
+      when 1
+        ERB::Util.html_escape(array[0])
+      when 2
+        safe_join([array[0], array[1]], options[:two_words_connector])
+      else
+        safe_join([safe_join(array[0...-1], options[:words_connector]), options[:last_word_connector], array[-1]], nil)
+      end
+    end
+  end
+end

data/lib/active_admin/helpers/routes/url_helpers.rb

@@ -0,0 +1,15 @@
+module ActiveAdmin
+  module Helpers
+    module Routes
+      module UrlHelpers
+        include Rails.application.routes.url_helpers
+      end
+
+      extend UrlHelpers
+
+      def self.default_url_options
+        Rails.application.routes.default_url_options || {}
+      end
+    end
+  end
+end

data/lib/active_admin/helpers/scope_chain.rb

@@ -0,0 +1,23 @@
+module ActiveAdmin
+  module ScopeChain
+    # Scope an ActiveRecord::Relation chain
+    #
+    # Example:
+    #   scope_chain(Scope.new(:published), Article)
+    #   # => Article.published
+    #
+    # @param scope The <ActiveAdmin::Scope> we want to scope on
+    # @param chain The ActiveRecord::Relation chain or ActiveRecord::Base class to scope
+    # @return <ActiveRecord::Relation or ActiveRecord::Base> The scoped relation chain
+    #
+    def scope_chain(scope, chain)
+      if scope.scope_method
+        chain.public_send scope.scope_method
+      elsif scope.scope_block
+        instance_exec chain, &scope.scope_block
+      else
+        chain
+      end
+    end
+  end
+end

data/lib/active_admin/inputs.rb

@@ -0,0 +1,21 @@
+module ActiveAdmin
+  module Inputs
+    extend ActiveSupport::Autoload
+
+    autoload :DatepickerInput
+
+    module Filters
+      extend ActiveSupport::Autoload
+
+      autoload :Base
+      autoload :StringInput
+      autoload :TextInput
+      autoload :DatePickerInput
+      autoload :DateRangeInput
+      autoload :NumericInput
+      autoload :SelectInput
+      autoload :CheckBoxesInput
+      autoload :BooleanInput
+    end
+  end
+end

data/lib/active_admin/inputs/datepicker_input.rb

@@ -0,0 +1,27 @@
+module ActiveAdmin
+  module Inputs
+    class DatepickerInput < ::Formtastic::Inputs::StringInput
+      def input_html_options
+        super.tap do |options|
+          options[:class] = [options[:class], "datepicker"].compact.join(' ')
+          options[:data] ||= {}
+          options[:data].merge! datepicker_options
+        end
+      end
+
+      # Can pass proc to filter label option
+      def label_from_options
+        res = super
+        res = res.call if res.is_a? Proc
+        res
+      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,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,49 @@
+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, gt_input_placeholder)),
+              builder.text_field(lt_input_name, input_html_options(lt_input_name, lt_input_placeholder)),
+            ].join("\n").html_safe
+          end
+        end
+
+        def gt_input_name
+          column && column.type == :date ? "#{method}_gteq" : "#{method}_gteq_datetime"
+        end
+        alias :input_name :gt_input_name
+
+        def lt_input_name
+          column && column.type == :date ? "#{method}_lteq" : "#{method}_lteq_datetime"
+        end
+
+        def input_html_options(input_name = gt_input_name, placeholder = gt_input_placeholder)
+          current_value = begin
+            #cast value to date object before rendering input
+            @object.public_send(input_name).to_s.to_date
+          rescue
+            nil
+          end
+          { size: 12,
+            class: "datepicker",
+            maxlength: 10,
+            placeholder: placeholder,
+            value: current_value ? current_value.strftime("%Y-%m-%d") : "" }
+        end
+
+        def gt_input_placeholder
+          I18n.t("active_admin.filters.predicates.from")
+        end
+
+        def lt_input_placeholder
+          I18n.t("active_admin.filters.predicates.to")
+        end
+      end
+    end
+  end
+end