activeadmin_addons 0.12.0 → 1.0.0

data/app/assets/javascripts/activeadmin_addons/inputs/tags.js

@@ -0,0 +1,73 @@
+$(function() {
+  setupTags(document);
+
+  $(document).on('has_many_add:after', function(event, container) {
+    setupTags(container);
+  });
+
+  function setupTags(container) {
+    $('.tags-input', container).each(function(i, el) {
+      var model = $(el).data('model');
+      var method = $(el).data('method');
+      var prefix = model + '_' + method;
+      var isRelation = !!$(el).data('relation');
+      var collection = $(el).data('collection');
+      var width = $(el).data('width');
+      var selectOptions = {
+        width: width,
+        multiple: true,
+        tags: true,
+        data: collection,
+      };
+
+      if (!!isRelation) {
+        selectOptions.createTag = function() {
+          return undefined;
+        };
+      }
+
+      $(el).on('select2:select', onItemAdded);
+      $(el).on('select2:unselect', onItemRemoved);
+      $(el).select2(selectOptions);
+
+      function getSelectedItems() {
+        var choices = $(el).parent('li.input').find('.select2-selection__choice');
+        return $.map(choices, function(item) {
+          return $(item).attr('title');
+        });
+      }
+
+      function fillHiddenInput() {
+        var hiddenInput = $('#' + prefix);
+        hiddenInput.val(getSelectedItems().join());
+      }
+
+      function onItemRemoved(event) {
+        if (isRelation) {
+          var itemId = '[id=\'' + prefix + '_' + event.params.data.id + '\']';
+          $(itemId).remove();
+        } else {
+          fillHiddenInput();
+        }
+      }
+
+      function onItemAdded(event) {
+        if (isRelation) {
+          var value = event.params.data.id;
+          var selectedItemsContainer = $("[id='" + prefix + "_selected_values']");
+          var itemName = model + '[' + method + '][]';
+          var itemId = prefix + '_' + value;
+
+          $('<input>').attr({
+            id: itemId,
+            name: itemName,
+            type: 'hidden',
+            value: value,
+          }).appendTo(selectedItemsContainer);
+        } else {
+          fillHiddenInput();
+        }
+      }
+    });
+  }
+});

data/app/assets/stylesheets/activeadmin_addons/all.scss

@@ -1,36 +1,17 @@
-@import "select2";
-@import "jquery.xdan.datetimepicker";
-@import "../palette-color-picker";
-@import "../selected-list";
+@import 'select2';
+@import 'jquery.xdan.datetimepicker';
+@import 'palette-color-picker';
 
-.filter_range_select {
-  input[type=number] {
-    padding-right: 0px;
-    width: 96px;
-  }
-  .separator {
-    display: inline-block;
-    text-align: center;
-    width: 12px;
-  }
-}
-
-.nested_select {
-  .nested-select-container {
-    margin-bottom: 20px;
+@import 'inputs/numeric-range-filter';
+@import 'inputs/color-picker';
+@import 'inputs/date-time-picker';
+@import 'inputs/select2';
+@import 'inputs/selected-list';
 
-    &:last-of-type {
-      margin-bottom: 0px;
-    }
-  }
-}
-
-.palette-color-picker-bubble {
-  z-index: 10;
-}
+$error-color: #932419;
 
-input[type=text] {
-  &.date-time-picker {
-    width: 110px;
+li.error {
+  .select2-selection {
+    border-color: $error-color;
   }
 }

data/app/assets/stylesheets/activeadmin_addons/inputs/color-picker.scss

@@ -0,0 +1,4 @@
+.palette-color-picker-bubble {
+  padding: 14px 0 14px 16px;
+  z-index: 10;
+}

data/app/assets/stylesheets/activeadmin_addons/inputs/date-time-picker.scss

@@ -0,0 +1,5 @@
+input[type=text] {
+  &.date-time-picker-input {
+    width: 110px;
+  }
+}

data/app/assets/stylesheets/activeadmin_addons/inputs/numeric-range-filter.scss

@@ -0,0 +1,12 @@
+.filter_numeric_range_filter {
+  input[type=number] {
+    width: 96px;
+    padding-right: 0;
+  }
+
+  .separator {
+    display: inline-block;
+    width: 12px;
+    text-align: center;
+  }
+}

data/app/assets/stylesheets/activeadmin_addons/inputs/select2.scss

@@ -0,0 +1,3 @@
+.select2-search__field {
+  line-height: 20px;
+}

data/app/assets/stylesheets/{selected-list.scss → activeadmin_addons/inputs/selected-list.scss}

@@ -1,10 +1,6 @@
-$selected-list-btn-color: #AAA;
+$selected-list-btn-color: #aaa;
 $selected-list-btn-hover-color: #333;
 
-.selected-list-label {
-  display: inline-block;
-}
-
 .selected-list-container {
   display: inline-block;
   width: 80%;

data/app/inputs/ajax_filter_input.rb

@@ -1,52 +1,6 @@
-class AjaxFilterInput < Formtastic::Inputs::StringInput
-  include ActiveAdmin::Inputs::Filters::Base
-
+class AjaxFilterInput < SearchSelectFilterInput
   def to_html
-    input_wrapping do
-      [
-        label_html,
-        builder.text_field(eq_input_name, input_html_options)
-      ].join("\n").html_safe
-    end
-  end
-
-  def eq_input_name
-    "#{method}_eq"
-  end
-
-  # rubocop:disable Metrics/CyclomaticComplexity
-  def input_html_options
-    opts = {}
-    opts[:class] = ['select2-ajax'].concat([@options[:class]] || []).join(' ')
-    opts["data-fields"] = (@options[:fields] || []).to_json
-    opts["data-url"] = 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] || "100%"
-    opts["data-selected"] = get_selected_value(opts["data-display_name"])
-    opts["data-order"] = @options[:order_by] if @options[:order_by]
-    super.merge opts
-  end
-
-  # rubocop:disable Style/RescueModifier
-  def get_selected_value(display_name)
-    association_name = method.to_s.chomp("_id")
-    association = @object.klass.reflect_on_association(association_name)
-    if association.options && association.options.keys.include?(:class_name)
-      filter_class = association.options[:class_name].constantize rescue @object.klass
-    else
-      filter_class = association_name.classify.constantize rescue @object.klass
-    end
-    selected_value = @object.conditions.find { |c| c.attributes.map(&:name).include?(method.to_s) }.values.first.value rescue nil
-    filter_class.find(selected_value).send(display_name) if !!selected_value
-  end
-
-  def url
-    if @options[:url].is_a?(Proc)
-      template.instance_eval(&@options[:url]) || ""
-    else
-      @options[:url] || ""
-    end
+    warn "[DEPRECATION] use :search_select_filter instead of :ajax_filter"
+    super
   end
 end

data/app/inputs/color_picker_input.rb

@@ -1,4 +1,4 @@
-class ColorPickerInput < Formtastic::Inputs::StringInput
+class ColorPickerInput < ActiveAdminAddons::InputBase
   DEFAULT_PALETTE = [
     "#000000",
     "#333333",
@@ -23,23 +23,15 @@ class ColorPickerInput < Formtastic::Inputs::StringInput
     "#FF99FF",
     "#FFCCCC",
     "#FFCC99",
-    "#FFFFFF",
+    "#FFFFFF"
   ]
 
-  def to_html
-    input_wrapping do
-      [
-        label_html,
-        builder.hidden_field(method, input_html_options),
-      ].join("\n").html_safe
-    end
+  def render_custom_input
+    concat(label_html)
+    concat(builder.hidden_field(method, input_html_options))
   end
 
-  def input_html_options
-    opts = {}
-    opts["class"] = 'color-picker'
-    opts["data-palette"] = (@options[:palette] || DEFAULT_PALETTE).to_json
-    opts["value"] = @object.public_send(method)
-    super.merge(opts)
+  def load_control_attributes
+    load_data_attr(:palette, default: DEFAULT_PALETTE, formatter: :to_json)
   end
 end

data/app/inputs/date_time_picker_input.rb

@@ -20,34 +20,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-class DateTimePickerInput < Formtastic::Inputs::StringInput
-  mattr_accessor :default_datetime_picker_options do
-    {}
+class DateTimePickerInput < ActiveAdminAddons::InputBase
+  def load_control_attributes
+    load_class(@options[:class])
+    load_data_attr(:picker_options, value: datetime_picker_options)
+    load_attr(:maxlength, value: 19)
+    load_attr(:value, value: formatted_input_value)
   end
 
-  mattr_accessor :format do
-    '%Y-%m-%d %H:%M'
-  end
-
-  def input_html_options(input_name = nil)
-    opts = {}
-    opts[:class] = [options[:class], 'date-time-picker'].compact.join(' ')
-    opts[:data] ||= {}
-    opts[:data].merge!(picker_options: datetime_picker_options)
-    opts[:value] ||= input_value(input_name)
-    opts[:maxlength] = 19
-    opts
-  end
-
-  def input_value(input_name = nil)
-    if options[:input_html] && options[:input_html].key?(:value)
-      return options[:input_html][:value]
-    end
-
-    v = !object.nil? ? object.public_send(input_name || method) : ''
+  def formatted_input_value
+    v = input_value
 
     if v.is_a?(Time)
-      return DateTime.new(v.year, v.month, v.day, v.hour, v.min, v.sec).strftime(format)
+      return DateTime.new(v.year, v.month, v.day, v.hour, v.min, v.sec).strftime(
+        ActiveadminAddons.datetime_picker_input_format
+      )
     end
 
     v.to_s
@@ -64,7 +51,7 @@ class DateTimePickerInput < Formtastic::Inputs::StringInput
   protected
 
   def default_picker_options
-    res = default_datetime_picker_options.map do |k, v|
+    res = ActiveadminAddons.datetime_picker_default_options.map do |k, v|
       if v.respond_to?(:call) || v.is_a?(Proc)
         [k, v.call]
       else

data/app/inputs/nested_level_input.rb

@@ -0,0 +1,49 @@
+class NestedLevelInput < ActiveAdminAddons::InputBase
+  include ActiveAdminAddons::SelectHelpers
+
+  def render_custom_input
+    concat(label_html)
+
+    select_control = builder.select(
+      method, initial_collection_to_select_options, {}, input_html_options
+    )
+
+    concat(select_control)
+  end
+
+  private
+
+  def load_control_attributes
+    load_class(@options[:class])
+    load_data_attr(:fields, default: ["name"], formatter: :to_json)
+    load_data_attr(:model, value: model_name)
+    load_data_attr(:display_name, default: "name")
+    load_data_attr(:minimum_input_length, default: 1)
+    load_data_attr(:url, default: url_from_method)
+    load_data_attr(:response_root, default: tableize_method)
+    load_data_attr(:width, default: "80%")
+    load_data_attr(:order,
+      value: @options[:order_by],
+      default: get_data_attr_value(:fields).first.to_s + "_desc")
+    load_parent_data_options
+    load_collection_data
+  end
+
+  def load_parent_data_options
+    return unless @options[:parent_attribute]
+    load_data_attr(:parent, value: @options[:parent_attribute])
+    load_data_attr(:parent_id, value: @object.send(@options[:parent_attribute]), default: -1)
+  end
+
+  def load_collection_data
+    return unless @options[:collection]
+
+    collection_options = collection_to_select_options do |item, option|
+      if !!@options[:parent_attribute]
+        option[@options[:parent_attribute]] = item.send(@options[:parent_attribute])
+      end
+    end
+
+    load_data_attr(:collection, value: collection_options, formatter: :to_json)
+  end
+end

data/app/inputs/nested_select_input.rb

@@ -1,55 +1,42 @@
-class NestedSelectInput < Formtastic::Inputs::StringInput
+class NestedSelectInput < ActiveAdminAddons::InputBase
   def to_html
-    html_elems = []
-
-    for_each_level do |level_data|
-      a = level_data[:attribute]
-      set_parent_value(level_data)
-      html_elems << builder.text_field(a, select_html_options(level_data))
-      html_elems << builder.label(a, translated_attribute(a))
-    end
-
-    input_wrapping do
-      html_elems.reverse.join("\n").html_safe
-    end
+    for_each_level { |attribute, data| concat(builder.input(attribute, level_options(data))) }
+    parts_to_html
   end
 
   private
 
   def for_each_level
-    hierarchy = get_hierarchy
-    hierarchy_count = hierarchy.count
-
-    hierarchy.each_with_index do |level_data, idx|
-      next_idx = idx + 1
-      parent_level_data = hierarchy[next_idx] if hierarchy_count != next_idx
-      level_data[:parent_attribute] = parent_level_data[:attribute] if parent_level_data
-
-      yield(level_data)
+    hierarchy.each do |level_data|
+      yield(level_data.delete(:attribute), level_data)
     end
   end
 
-  def get_hierarchy
-    hierarchy = []
-    levels = @options.keys.select { |key| key.to_s.match(/level_[1-9]$/) }
-    reversed_levels = levels.reverse
+  def hierarchy
+    data = get_levels_data
+    raise("Undefined levels on nested_select") if data.empty?
+    set_parent_attributes(data)
+    data.reverse
+  end
 
-    reversed_levels.each_with_index do |level_key, idx|
-      previous_level_key = reversed_levels[idx + 1]
+  def get_levels_data
+    levels_data = []
+    levels = @options.keys.select { |key| key.to_s.match(/level_[1-9]$/) }.reverse
+
+    levels.each_with_index do |level_key, idx|
+      previous_level_key = levels[idx + 1]
       validate_level_data!(level_key, previous_level_key)
-      hierarchy << @options[level_key]
+      levels_data << @options.delete(level_key)
     end
 
-    raise("Undefined levels on nested_select") if hierarchy.empty?
-
-    hierarchy
+    levels_data
   end
 
   def validate_level_data!(level_key, previous_level_key)
     current_level_number = get_level_number(level_key)
     previous_level_number = get_level_number(previous_level_key)
 
-    if !(current_level_number == previous_level_number + 1)
+    if current_level_number != (previous_level_number + 1)
       raise("Missing :level_#{current_level_number - 1} key")
     end
 
@@ -61,54 +48,24 @@ class NestedSelectInput < Formtastic::Inputs::StringInput
     level_key.to_s.split("_").last.to_i
   end
 
-  def select_html_options(level)
-    attribute = level[:attribute]
-    instance = instance_from_attribute_name(attribute)
-
-    opts = {}
-    opts["class"] = select_classes(level)
-    opts["data-fields"] = get_option(level, :fields, ["name"]).to_json
-    opts["data-model"] = model_name
-    opts["data-display_name"] = get_option(level, :display_name,  "name")
-    opts["data-minimum_input_length"] = get_option(level, :minimum_input_length, 1)
-    opts["data-collection"] = (level[:collection] || nil).to_json
-
-    opts["id"] = build_select_id(attribute)
-    opts["data-url"] = get_option(level, :url, build_url(attribute))
-    opts["data-response_root"] = (level[:response_root] || opts["data-url"].to_s.split('/').last)
-    opts["data-selected"] = instance.try(opts["data-display_name"])
-
-    opts.merge(select_html_parent_options(level[:parent_attribute]))
-  end
-
-  def select_html_parent_options(parent_attribute)
-    opts = {}
-    return opts unless parent_attribute
-    opts["data-parent"] = parent_attribute
-    opts["data-parent_id"] = @object.send(parent_attribute)
-    opts
-  end
-
-  def select_classes(level_data)
-    ['select2-ajax'].concat(get_option(level_data, :class, [])).join(' ')
-  end
-
-  def model_name
-    @object.class.to_s.underscore.tr("/", "_")
-  end
-
-  def build_select_id(attribute)
-    [model_name, attribute.to_s].join("_")
+  def level_options(data)
+    @options.merge(data).merge(as: :nested_level)
   end
 
-  def get_option(level_data, option, default)
-    level_data[option] || @options[option] || default
+  def set_parent_attributes(hierarchy)
+    hierarchy.each_with_index do |level_data, idx|
+      next_idx = idx + 1
+      parent_level_data = hierarchy[next_idx] if hierarchy.count != next_idx
+      if parent_level_data
+        level_data[:parent_attribute] = parent_level_data[:attribute]
+        set_parent_value(level_data)
+      end
+    end
   end
 
   def set_parent_value(level_data)
     parent_attribute = level_data[:parent_attribute]
-    return unless parent_attribute
-    add_virtual_accessor(parent_attribute)
+    build_virtual_attr(parent_attribute)
     instance = instance_from_attribute_name(level_data[:attribute])
     if instance && instance.respond_to?(parent_attribute)
       @object.send("#{parent_attribute}=", instance.send(parent_attribute))
@@ -123,24 +80,8 @@ class NestedSelectInput < Formtastic::Inputs::StringInput
     klass.find_by_id(attribute_value)
   end
 
-  def add_virtual_accessor(attribute)
-    return unless attribute
-    @object.singleton_class.send(:attr_accessor, attribute) unless @object.respond_to?(attribute)
-  end
-
-  def translated_attribute(attribute)
-    @object.class.human_attribute_name(attribute)
-  end
-
-  def build_url(attribute)
-    url = ["/"]
-
-    if ActiveAdmin.application.default_namespace.present?
-      url << "#{ActiveAdmin.application.default_namespace}/"
-    end
-
-    url << attribute.to_s.chomp("_id").tableize
-
-    url.join("")
+  def build_virtual_attr(attribute_name)
+    fail "#{attribute_name} is already defined" if @object.respond_to?(attribute_name)
+    @object.singleton_class.send(:attr_accessor, attribute_name)
   end
 end