activeadmin 2.2.0

data/lib/active_admin/form_builder.rb

@@ -0,0 +1,182 @@
+# Provides an intuitive way to build has_many associated records in the same form.
+module Formtastic
+  module Inputs
+    module Base
+      def input_wrapping(&block)
+        html = super
+        template.concat(html) if template.output_buffer && template.assigns[:has_many_block]
+        html
+      end
+    end
+  end
+end
+
+module ActiveAdmin
+  class FormBuilder < ::Formtastic::FormBuilder
+
+    self.input_namespaces = [::Object, ::ActiveAdmin::Inputs, ::Formtastic::Inputs]
+
+    # TODO: remove both class finders after formtastic 4 (where it will be default)
+    self.input_class_finder = ::Formtastic::InputClassFinder
+    self.action_class_finder = ::Formtastic::ActionClassFinder
+
+    def cancel_link(url = { action: "index" }, html_options = {}, li_attrs = {})
+      li_attrs[:class] ||= "cancel"
+      li_content = template.link_to I18n.t('active_admin.cancel'), url, html_options
+      template.content_tag(:li, li_content, li_attrs)
+    end
+
+    attr_accessor :already_in_an_inputs_block
+
+    def has_many(assoc, options = {}, &block)
+      HasManyBuilder.new(self, assoc, options).render(&block)
+    end
+  end
+
+  # Decorates a FormBuilder with the additional attributes and methods
+  # to build a has_many block.  Nested has_many blocks are handled by
+  # nested decorators.
+  class HasManyBuilder < SimpleDelegator
+    attr_reader :assoc
+    attr_reader :options
+    attr_reader :heading, :sortable_column, :sortable_start
+    attr_reader :new_record, :destroy_option
+
+    def initialize(has_many_form, assoc, options)
+      super has_many_form
+      @assoc = assoc
+      @options = extract_custom_settings!(options.dup)
+      @options.reverse_merge!(for: assoc)
+      @options[:class] = [options[:class], "inputs has_many_fields"].compact.join(' ')
+
+      if sortable_column
+        @options[:for] = [assoc, sorted_children(sortable_column)]
+      end
+    end
+
+    def render(&block)
+      html = "".html_safe
+      html << template.content_tag(:h3) { heading } if heading.present?
+      html << template.capture { content_has_many(&block) }
+      html = wrap_div_or_li(html)
+      template.concat(html) if template.output_buffer
+      html
+    end
+
+    protected
+
+    # remove options that should not render as attributes
+    def extract_custom_settings!(options)
+      @heading = options.key?(:heading) ? options.delete(:heading) : default_heading
+      @sortable_column = options.delete(:sortable)
+      @sortable_start  = options.delete(:sortable_start) || 0
+      @new_record = options.key?(:new_record) ? options.delete(:new_record) : true
+      @destroy_option = options.delete(:allow_destroy)
+      options
+    end
+
+    def default_heading
+      assoc_klass.model_name.
+        human(count: ::ActiveAdmin::Helpers::I18n::PLURAL_MANY_COUNT)
+    end
+
+    def assoc_klass
+      @assoc_klass ||= __getobj__.object.class.reflect_on_association(assoc).klass
+    end
+
+    def content_has_many(&block)
+      form_block = proc do |form_builder|
+        render_has_many_form(form_builder, options[:parent], &block)
+      end
+
+      template.assigns[:has_many_block] = true
+      contents = without_wrapper { inputs(options, &form_block) }
+      contents ||= "".html_safe
+
+      js = new_record ? js_for_has_many(options[:class], &form_block) : ''
+      contents << js
+    end
+
+    # Renders the Formtastic inputs then appends ActiveAdmin delete and sort actions.
+    def render_has_many_form(form_builder, parent, &block)
+      index = parent && form_builder.send(:parent_child_index, parent)
+      template.concat template.capture { yield(form_builder, index) }
+      template.concat has_many_actions(form_builder, "".html_safe)
+    end
+
+    def has_many_actions(form_builder, contents)
+      if form_builder.object.new_record?
+        contents << template.content_tag(:li) do
+          template.link_to I18n.t('active_admin.has_many_remove'), "#", class: 'button has_many_remove'
+        end
+      elsif allow_destroy?(form_builder.object)
+        form_builder.input(:_destroy, as: :boolean,
+                            wrapper_html: { class: 'has_many_delete' },
+                            label: I18n.t('active_admin.has_many_delete'))
+      end
+
+      if sortable_column
+        form_builder.input sortable_column, as: :hidden
+
+        contents << template.content_tag(:li, class: 'handle') do
+          I18n.t('active_admin.move')
+        end
+      end
+
+      contents
+    end
+
+    def allow_destroy?(form_object)
+      !! case destroy_option
+         when Symbol, String
+           form_object.public_send destroy_option
+         when Proc
+           destroy_option.call form_object
+         else
+           destroy_option
+         end
+    end
+
+    def sorted_children(column)
+      __getobj__.object.public_send(assoc).sort_by do |o|
+        attribute = o.public_send column
+        [attribute.nil? ? Float::INFINITY : attribute, o.id || Float::INFINITY]
+      end
+    end
+
+    def without_wrapper
+      is_being_wrapped = already_in_an_inputs_block
+      self.already_in_an_inputs_block = false
+
+      html = yield
+
+      self.already_in_an_inputs_block = is_being_wrapped
+      html
+    end
+
+    # Capture the ADD JS
+    def js_for_has_many(class_string, &form_block)
+      assoc_name       = assoc_klass.model_name
+      placeholder      = "NEW_#{assoc_name.to_s.underscore.upcase.gsub(/\//, '_')}_RECORD"
+      opts = {
+        for: [assoc, assoc_klass.new],
+        class: class_string,
+        for_options: { child_index: placeholder }
+      }
+      html = template.capture { __getobj__.send(:inputs_for_nested_attributes, opts, &form_block) }
+      text = new_record.is_a?(String) ? new_record : I18n.t('active_admin.has_many_new', model: assoc_name.human)
+
+      template.link_to text, '#', class: "button has_many_add", data: {
+        html: CGI.escapeHTML(html).html_safe, placeholder: placeholder
+      }
+    end
+
+    def wrap_div_or_li(html)
+      template.content_tag(already_in_an_inputs_block ? :li : :div,
+                           html,
+                           class: "has_many_container #{assoc}",
+                           'data-sortable' => sortable_column,
+                           'data-sortable-start' => sortable_start)
+    end
+  end
+end

data/lib/active_admin/generators/boilerplate.rb

@@ -0,0 +1,45 @@
+module ActiveAdmin
+  module Generators
+    class Boilerplate
+      def initialize(class_name)
+        @class_name = class_name
+      end
+
+      def attributes
+        @class_name.constantize.new.attributes.keys
+      end
+
+      def rows
+        attributes.map { |a| row(a) }.join("\n")
+      end
+
+      def row(name)
+        "#   row :#{name.gsub(/_id$/, '')}"
+      end
+
+      def columns
+        attributes.map { |a| column(a) }.join("\n")
+      end
+
+      def column(name)
+        "#   column :#{name.gsub(/_id$/, '')}"
+      end
+
+      def filters
+        attributes.map { |a| filter(a) }.join("\n")
+      end
+
+      def filter(name)
+        "# filter :#{name.gsub(/_id$/, '')}"
+      end
+
+      def form_inputs
+        attributes.reject { |a| %w(id created_at updated_at).include? a }.map { |a| form_input(a) }.join("\n")
+      end
+
+      def form_input(name)
+        "#     f.input :#{name.gsub(/_id$/, '')}"
+      end
+    end
+  end
+end

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/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,24 @@
+module ActiveAdmin
+  module ScopeChain
+    private
+    # 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