activeadmin_addons 0.12.0 → 1.0.0

data/app/inputs/numeric_range_filter_input.rb

@@ -0,0 +1,27 @@
+class NumericRangeFilterInput < ActiveAdminAddons::InputBase
+  include ActiveAdminAddons::FilterInput
+
+  def render_custom_input
+    concat(label_html)
+    concat_text_field(gteq_input_name)
+    concat(build_separator)
+    concat_text_field(lteq_input_name)
+  end
+
+  def concat_text_field(control_name)
+    concat(builder.text_field(control_name, input_html_options(control_name)))
+  end
+
+  alias :input_name :gteq_input_name
+
+  def input_html_options(input_name = gteq_input_name)
+    is_gt = (input_name == gteq_input_name)
+
+    {
+      type: "number",
+      step: "any",
+      value: @object.public_send(input_name),
+      placeholder: is_gt ? "min" : "max"
+    }
+  end
+end

data/app/inputs/range_select_input.rb

@@ -1,35 +1,6 @@
-class RangeSelectInput < Formtastic::Inputs::StringInput
-  include ActiveAdmin::Inputs::Filters::Base
-
+class RangeSelectInput < NumericRangeFilterInput
   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: "separator"),
-        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)
-    is_gt = (input_name == gt_input_name)
-
-    {
-      type: "number",
-      step: "any",
-      value: @object.public_send(input_name),
-      placeholder: is_gt ? "min" : "max"
-    }
+    warn "[DEPRECATION] use :numeric_range_filter instead of :range_select"
+    super
   end
 end

data/app/inputs/search_select_filter_input.rb

@@ -0,0 +1,12 @@
+class SearchSelectFilterInput < SearchSelectInput
+  include ActiveAdminAddons::FilterInput
+
+  def load_control_attributes
+    super
+    load_data_attr(:width, default: "resolve")
+  end
+
+  def input_method
+    eq_input_name
+  end
+end

data/app/inputs/search_select_input.rb

@@ -1,16 +1,28 @@
-class SearchSelectInput < Formtastic::Inputs::StringInput
-  def input_html_options
-    relation = !@object.nil? ? @object.send(attributized_method_name) : ''
-    opts = {}
-    opts[:class] = ['select2-ajax'].concat([@options[:class]] || []).join(' ')
-    opts["data-fields"] = (@options[:fields] || []).to_json
-    opts["data-url"] = @options[:url] || ""
-    opts["data-response_root"] = @options[:response_root] || @options[:url].to_s.split('/').last
-    opts["data-display_name"] = @options[:display_name] || "name"
-    opts["data-minimum_input_length"] = @options[:minimum_input_length] || 1
-    opts["data-width"] = @options[:width] if @options[:width]
-    opts["data-selected"] = relation.try(opts["data-display_name"].to_sym)
-    opts["data-order"] = @options[:order_by] if @options[:order_by]
-    super.merge opts
+class SearchSelectInput < ActiveAdminAddons::InputBase
+  include ActiveAdminAddons::SelectHelpers
+
+  def render_custom_input
+    concat(label_html)
+    concat(builder.select(input_method,
+      initial_collection_to_select_options, {}, input_html_options))
+  end
+
+  def input_method
+    valid_method
+  end
+
+  def load_control_attributes
+    load_class(@options[:class])
+    load_data_attr(:fields, default: ["name"], formatter: :to_json)
+    load_data_attr(:url, default: url_from_method)
+    load_data_attr(:response_root, default: tableize_method)
+    load_data_attr(:display_name, default: "name")
+    load_data_attr(:minimum_input_length, default: 1)
+    load_data_attr(:width, default: "80%")
+    load_data_attr(
+      :order,
+      value: @options[:order_by],
+      default: get_data_attr_value(:fields).first.to_s + "_desc"
+    )
   end
 end

data/app/inputs/selected_list_input.rb

@@ -1,94 +1,53 @@
-class SelectedListInput < Formtastic::Inputs::StringInput
-  # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-  def input_html_options
-    opts = {}
-    opts[:class] = ["selected-list"].concat([@options[:class]] || []).join(' ')
-    opts["data-model"] = model_name
-    opts["data-method"] = method
-    opts["data-url"] = @options[:url] || build_url
-    opts["data-response_root"] = @options[:response_root] || opts["data-url"].split('/').last
-    opts["data-fields"] = (@options[:fields] || ["name"]).to_json
-    opts["data-display_name"] = @options[:display_name] || "name"
-    opts["data-minimum_input_length"] = @options[:minimum_input_length] || 1
-    opts["data-width"] = @options[:width] if @options[:width]
-    opts["data-order"] = @options[:order_by] if @options[:order_by]
-    super.merge(opts)
-  end
-
-  def to_html
-    input_wrapping do
-      [
-        builder.label(translated_attribute(method), class: "selected-list-label"),
-        render_control_wrapper
-      ].flatten.join("\n").html_safe
-    end
-  end
+class SelectedListInput < ActiveAdminAddons::InputBase
+  def render_custom_input
+    concat(label_html)
+    concat(render_control_wrapper)
+  end
+
+  def load_control_attributes
+    load_class(@options[:class])
+    load_data_attr(:model, value: model_name)
+    load_data_attr(:method, value: method)
+    load_data_attr(:url, default: url_from_method)
+    load_data_attr(:response_root, default: tableize_method)
+    load_data_attr(:fields, default: ["name"], formatter: :to_json)
+    load_data_attr(:display_name, default: "name")
+    load_data_attr(:minimum_input_length, default: 1)
+    load_data_attr(:width, default: "100%")
+    load_data_attr(
+      :order,
+      value: @options[:order_by],
+      default: get_data_attr_value(:fields).first.to_s + "_desc"
+    )
+  end
+
+  private
 
   def render_control_wrapper
     template.content_tag(:div, class: "selected-list-container") do
       template.content_tag(label_html)
       template.concat(render_items_list)
-      template.concat(builder.text_field(virtual_attr, input_html_options))
+      template.concat(builder.select(build_virtual_attr, [], {}, input_html_options))
     end
   end
 
   def render_items_list
-    prefix = "#{model_name}_#{method}"
-    attr_name = "#{model_name}[#{method}][]"
-    template.content_tag(:div, id: "#{prefix}_selected_values", class: "selected-values") do
-      template.concat(
-        builder.hidden_field(method, id: "#{prefix}_empty", name: attr_name, value: nil)
-      )
-      @object.send(method).each do |item_id|
-        template.concat(render_item_label(prefix, attr_name, item_id))
-      end
+    template.content_tag(:div, id: selected_values_id, class: "selected-values") do
+      template.concat(build_hidden_control(empty_input_id, method_to_input_array_name, ""))
+      input_related_items.each { |item| template.concat(render_item(item)) }
     end
   end
 
-  def render_item_label(prefix, attr_name, item_id)
-    attr_id = "#{prefix}_#{item_id}"
-    div_config = { id: attr_id, class: "selected-item" }
-    template.content_tag(:div, div_config) do
-      template.concat(item_label(item_id))
-      template.concat(builder.hidden_field(nil, id: nil, name: attr_name, value: item_id))
-    end
-  end
-
-  def item_label(item_id)
-    selected_items.find { |item| item.id == item_id }.send(@options[:display_name] || "name")
-  end
-
-  def selected_items
-    @selected_items ||= @object.send(relation_name)
-  end
-
-  def translated_attribute(attribute)
-    @object.class.human_attribute_name(attribute)
-  end
-
-  def model_name
-    @object.class.to_s.underscore.tr('/', '_')
-  end
-
-  def virtual_attr
-    attr_name = "#{method}_str".to_sym
-    @object.singleton_class.send(:attr_accessor, attr_name) unless @object.respond_to?(attr_name)
-    attr_name
-  end
-
-  def build_url
-    url = ["/"]
-
-    if ActiveAdmin.application.default_namespace.present?
-      url << "#{ActiveAdmin.application.default_namespace}/"
+  def render_item(item)
+    template.content_tag(:div, id: method_to_input_id(item.id), class: "selected-item") do
+      template.concat(item_label(item))
+      template.concat(
+        build_hidden_control(method_to_input_id(item.id), method_to_input_array_name, item.id.to_s)
+      )
     end
-
-    url << relation_name
-
-    url.join("")
   end
 
-  def relation_name
-    method.to_s.chomp("_ids").tableize
+  def item_label(item)
+    item.send(@options[:display_name] || "name")
   end
 end

data/app/inputs/tags_input.rb

@@ -1,87 +1,55 @@
-class TagsInput < Formtastic::Inputs::StringInput
-  def input_html_options
-    opts = {}
-    opts[:class] = "select2-tags"
-    opts["data-width"] = @options[:width] if @options[:width]
-    super.merge(opts)
-  end
-
-  def to_html
-    relation? ? render_tags_from_relation : render_tags
-  end
+class TagsInput < ActiveAdminAddons::InputBase
+  include ActiveAdminAddons::SelectHelpers
 
-  def relation?
-    @object.send(attributized_method_name).respond_to?(:each) &&
-      @options[:collection].class.name == "ActiveRecord::Relation"
-  end
-
-  def render_tags
-    input_wrapping do
-      [
-        label_html,
-        builder.text_field(method, tag_options)
-      ].join("\n").html_safe
+  def render_custom_input
+    if active_record_select?
+      return render_collection_tags
     end
+
+    render_array_tags
   end
 
-  def render_tags_from_relation
-    virtual_input_name = build_virtual_attr
+  def load_control_attributes
+    load_data_attr(:model, value: model_name)
+    load_data_attr(:method, value: method)
+    load_data_attr(:width, default: "80%")
 
-    input_wrapping do
-      [
-        label_html,
-        render_selected_hidden_items,
-        builder.text_field(virtual_input_name, relation_tag_options)
-      ].flatten.join("\n").html_safe
+    if active_record_select?
+      load_data_attr(:relation, value: true)
+      load_data_attr(:collection, value: collection_to_select_options, formatter: :to_json)
+    else
+      load_data_attr(:collection, value: array_to_select_options, formatter: :to_json)
     end
   end
 
-  def tag_options
-    opts = input_html_options
-    opts["data-collection"] = (@options[:collection] || []).to_json
-    opts
-  end
+  private
 
-  def relation_tag_options
-    opts = input_html_options
-    opts["data-model"] = model_name
-    opts["data-method"] = method
-
-    if @options[:collection].class.name != "ActiveRecord::Relation"
-      fail "collection must be an ActiveRecord::Relation instance"
-    end
-
-    opts["data-collection"] = @options[:collection].map do |item|
-      {
-        id: item.send((@options[:value] || "id")),
-        text: item.send((@options[:display_name] || "name"))
-      }
-    end.to_json
+  def render_array_tags
+    render_tags_control { build_hidden_control(prefixed_method, method_to_input_name, input_value) }
+  end
 
-    opts
+  def render_collection_tags
+    render_tags_control { render_selected_hidden_items }
   end
 
-  def build_virtual_attr
-    attr_name = "#{method}_str"
-    @object.singleton_class.send(:attr_accessor, attr_name) unless @object.respond_to?(attr_name)
-    @object.send("#{attr_name}=", @object.send(method).join(","))
-    attr_name.to_sym
+  def render_tags_control(&block)
+    concat(label_html)
+    concat(block.call)
+    concat(builder.select(build_virtual_attr, [], {}, input_html_options))
   end
 
   def render_selected_hidden_items
-    prefix = "#{model_name}_#{method}"
-    attr_name = "#{model_name}[#{method}][]"
-    template.content_tag(:div, id: "#{prefix}_selected_values") do
-      template.concat(
-        builder.hidden_field(method, id: "#{prefix}_empty", name: attr_name, value: nil))
-      @object.send(method).each do |item_id|
-        attr_id = "#{prefix}_#{item_id}"
-        template.concat(builder.hidden_field(method, id: attr_id, name: attr_name, value: item_id))
+    template.content_tag(:div, id: selected_values_id) do
+      template.concat(build_hidden_control(empty_input_id, method_to_input_array_name, ""))
+      input_value.each do |item_id|
+        template.concat(
+          build_hidden_control(
+            method_to_input_id(item_id),
+            method_to_input_array_name,
+            item_id.to_s
+          )
+        )
       end
     end
   end
-
-  def model_name
-    @object.class.to_s.underscore.tr('/', '_')
-  end
 end

data/lib/activeadmin_addons.rb

@@ -1,13 +1,23 @@
 module ActiveadminAddons
   extend self
 
-  attr_writer :default_select
+  attr_writer :default_select, :datetime_picker_default_options, :datetime_picker_input_format
 
   def default_select
     return "select2" unless @default_select
     @default_select
   end
 
+  def datetime_picker_default_options
+    return {} unless @datetime_picker_default_options
+    @datetime_picker_default_options
+  end
+
+  def datetime_picker_input_format
+    return "%Y-%m-%d %H:%M" unless @datetime_picker_input_format
+    @datetime_picker_input_format
+  end
+
   def setup
     yield self
     require "activeadmin_addons"

data/lib/activeadmin_addons/addons/{paperclip_attachment.rb → attachment_builder.rb}

@@ -1,5 +1,5 @@
 module ActiveAdminAddons
-  class PaperclipAttachmentBuilder < CustomBuilder
+  class AttachmentBuilder < CustomBuilder
     KNOWN_EXTENSIONS = %w{
       3gp 7z ace ai aif aiff amr asf asx bat bin bmp bup cab cbr cda cdl cdr chm
       dat divx dll dmg doc docx dss dvf dwg eml eps exe fla flv gif gz hqx htm html
@@ -14,7 +14,7 @@ module ActiveAdminAddons
     end
 
     def for_ext(file_extension)
-      ext = file_extension.start_with?('.') ? file_extension[1..-1] : file_extension
+      ext = file_extension.start_with?(".") ? file_extension[1..-1] : file_extension
       ext.downcase!
       ext = "unknown" unless KNOWN_EXTENSIONS.include?(ext)
       "fileicons/file_extension_#{ext}.png"
@@ -33,19 +33,19 @@ module ActiveAdminAddons
     end
 
     def label_text
-      label =
-        if options[:label].nil?
-          file.original_filename
-        elsif options[:label].is_a? Proc
-          options[:label].call(model).to_s
-        else
-          options[:label].to_s
-        end
+      label = if options[:label].nil?
+                file.original_filename
+              elsif options[:label].is_a? Proc
+                options[:label].call(model).to_s
+              else
+                options[:label].to_s
+              end
+
       options[:truncate] ? context.truncate(label) : label
     end
 
     def render
-      raise 'you need to pass a paperclip attribute' unless file.respond_to?(:url)
+      raise "you need to pass a paperclip attribute" unless file.respond_to?(:url)
       options[:truncate] = options.fetch(:truncate, true)
       return nil unless file.exists?
       context.link_to(build_label, file.url, target: "_blank", class: "attachment-link")
@@ -55,19 +55,6 @@ module ActiveAdminAddons
       model.send(attribute)
     end
   end
-
-  module ::ActiveAdmin
-    module Views
-      class TableFor
-        def attachment_column(*args, &block)
-          column(*args) { |model| PaperclipAttachmentBuilder.render(self, model, *args, &block) }
-        end
-      end
-      class AttributesTable
-        def attachment_row(*args, &block)
-          row(*args) { |model| PaperclipAttachmentBuilder.render(self, model, *args, &block) }
-        end
-      end
-    end
-  end
 end
+
+ActiveAdminAddons::AttachmentBuilder.create_view_methods