Merge pull request #462 from platanus/use-association-name-in-selects

Use association name in selects

Author: difernandez

CHANGELOG.md

@@ -6,6 +6,7 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 #### Breaking changes
 * Defines required ruby version to >=2.7.0 [#460](https://github.com/platanus/activeadmin_addons/pull/460)
+* Nested and search select now use the name of the association instead of the name of id [#462](https://github.com/platanus/activeadmin_addons/pull/462)
 
 ### 2.0.0.beta-0
 

README.md

@@ -225,11 +225,13 @@ filter :created_at, as: :date_time_picker_filter
 You can use the ajax select input to filter values on index view like this:
 
 ```ruby
-filter :category_id, as: :search_select_filter
+filter :category, as: :search_select_filter
 ```
 
 <img src="./docs/images/filter-search-select.png" height="160" />
 
+[Read more!](docs/slim-select_search.md#filter-usage)
+
 ### Themes
 
 #### NO Theme

app/inputs/nested_level_input.rb

@@ -1,4 +1,4 @@
-class NestedLevelInput < ActiveAdminAddons::InputBase
+class NestedLevelInput < ActiveAdminAddons::SelectInputBase
   include ActiveAdminAddons::SelectHelpers
 
   def render_custom_input
@@ -38,15 +38,17 @@ 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)
+    load_data_attr(
+      :parent_id, value: @object.send(@options[:parent_id_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])
+      if @options[:parent_attribute].present?
+        option[@options[:parent_id_attribute]] = item.send(@options[:parent_id_attribute])
       end
     end
 

app/inputs/nested_select_input.rb

@@ -59,32 +59,38 @@ def set_parent_attributes(hierarchy)
       parent_level_data = hierarchy[next_idx] if hierarchy.count != next_idx
       if parent_level_data
         level_data[:parent_attribute] = parent_level_data[:attribute]
+        level_data[:parent_id_attribute] = "#{level_data[:parent_attribute]}_id"
         set_parent_value(level_data)
       end
     end
   end
 
   def set_parent_value(level_data)
-    parent_attribute = level_data[:parent_attribute]
-    build_virtual_attr(parent_attribute)
-    instance = instance_from_attribute_name(level_data[:attribute])
-    if instance&.respond_to?(parent_attribute)
-      @object.send("#{parent_attribute}=", instance.send(parent_attribute))
+    build_virtual_attr(level_data[:parent_attribute])
+    build_virtual_attr(level_data[:parent_id_attribute])
+    instance = instance_from_attribute_id("#{level_data[:attribute]}_id")
+    if instance.respond_to?(level_data[:parent_id_attribute])
+      @object.send(
+        "#{level_data[:parent_attribute]}=", instance.send(level_data[:parent_attribute])
+      )
+      @object.send(
+        "#{level_data[:parent_id_attribute]}=", instance.send(level_data[:parent_id_attribute])
+      )
     end
   end
 
-  def instance_from_attribute_name(attribute)
-    return unless attribute
+  def instance_from_attribute_id(attribute_id)
+    return unless attribute_id
 
-    attribute_value = @object.send(attribute)
-    return unless attribute_value
+    attribute_id_value = @object.send(attribute_id)
+    return unless attribute_id_value
 
-    klass = class_from_attribute(attribute)
-    klass.find_by(id: attribute_value)
+    klass = class_from_attribute_id(attribute_id)
+    klass.find_by(id: attribute_id_value)
   end
 
-  def class_from_attribute(attribute)
-    association_name = attribute.to_s.chomp("_id")
+  def class_from_attribute_id(attribute_id)
+    association_name = attribute_id.to_s.chomp("_id")
     association_name.camelize.constantize
   rescue NameError
     object_class.reflect_on_association(association_name).klass

app/inputs/search_select_filter_input.rb

@@ -7,6 +7,20 @@ def load_control_attributes
   end
 
   def input_method
-    eq_input_name
+    "#{input_name}_eq"
+  end
+
+  def input_html_options_name
+    "#{object_name}[#{input_method}]"
+  end
+
+  def input_value
+    result = valid_object.conditions.find do |condition|
+      condition.attributes.map(&:name).include?(input_name.to_s)
+    end
+
+    return unless result
+
+    result.values.first.value
   end
 end

app/inputs/search_select_input.rb

@@ -1,4 +1,4 @@
-class SearchSelectInput < ActiveAdminAddons::InputBase
+class SearchSelectInput < ActiveAdminAddons::SelectInputBase
   include ActiveAdminAddons::SelectHelpers
 
   def render_custom_input

app/javascript/activeadmin_addons/inputs/slim-select-nested.js

@@ -12,7 +12,7 @@ function ajaxSearch(search, currentData, args) {
   });
 
   if (!!args.parent) {
-    args.query.q[`${args.parent}_eq`] = args.parentId;
+    args.query.q[`${args.parent}_id_eq`] = args.parentId;
   }
 
   args.query.q = { ...args.query.q, ...args.filters };
@@ -48,7 +48,7 @@ function settings(el) {
         const { model, association } = el.dataset;
         const child = el.closest('.nested_level')
           .parentNode
-          .querySelector(`.nested_level [data-model=${model}][data-parent=${association}_id]`);
+          .querySelector(`.nested_level [data-model=${model}][data-parent=${association}]`);
 
         if (child) {
           child.slim.setSelected();

docs/slim-select_nested_select.md

@@ -36,10 +36,10 @@ end
 to enable nested select functionality, you we'll need to do the following:
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  level_1: { attribute: :country_id },
-                  level_2: { attribute: :region_id },
-                  level_3: { attribute: :city_id }
+f.input :city, as: :nested_select,
+               level_1: { attribute: :country },
+               level_2: { attribute: :region },
+               level_3: { attribute: :city }
 ```
 
 <img src="./images/slim-select-nested-select.gif" />
@@ -48,39 +48,39 @@ By default, the nested select input uses the index action of the different level
 It's not mandatory to register the ActiveAdmin pages. But, if you don't, you'll need to pass the `url` attribute, on each level, to make it work.
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  level_1: {
-                    attribute: :country_id,
-                    url: '/api/countries'
-                  },
-                  level_2: {
-                    attribute: :region_id,
-                    url: '/api/regions'
-                  },
-                  level_3: {
-                    attribute: :city_id,
-                    url: '/api/cities'
-                  }
+f.input :city, as: :nested_select,
+               level_1: {
+                 attribute: :country,
+                 url: '/api/countries'
+               },
+               level_2: {
+                 attribute: :region,
+                 url: '/api/regions'
+               },
+               level_3: {
+                 attribute: :city,
+                 url: '/api/cities'
+               }
 ```
 
 > Remember: those custom endpoints need to work with Ransack filters.
 
 Another option is to pass the `collection` attribute. If you set this, the `url` attribute will be ignored (no ajax request will be executed) and you will work with preloaded collections.
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  level_1: {
-                    attribute: :country_id,
-                    collection: Country.all
-                  },
-                  level_2: {
-                    attribute: :region_id,
-                    collection: Region.active
-                  },
-                  level_3: {
-                    attribute: :city_id,
-                    collection: City.all
-                  }
+f.input :city, as: :nested_select,
+               level_1: {
+                 attribute: :country,
+                 collection: Country.all
+               },
+               level_2: {
+                 attribute: :region,
+                 collection: Region.active
+               },
+               level_3: {
+                 attribute: :city,
+                 collection: City.all
+               }
 ```
 
 ### Options
@@ -94,38 +94,38 @@ Nested select, allows you to customize the general behavior of the input:
 * `predicate`: **(optional)** You can change the default [ransack predicate](https://github.com/activerecord-hackery/ransack#search-matchers). It **defaults to** `contains`
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  fields: [:name, :id],
-                  display_name: :id,
-                  minimum_input_length: 1,
-                  level_1: { attribute: :country_id },
-                  level_2: { attribute: :region_id },
-                  level_3: { attribute: :city_id }
+f.input :city, as: :nested_select,
+               fields: [:name, :id],
+               display_name: :id,
+               minimum_input_length: 1,
+               level_1: { attribute: :country },
+               level_2: { attribute: :region },
+               level_3: { attribute: :city }
 ```
 
 <img src="./images/slim-select-nested-select-general-options.gif" />
 
 Also, you can redefine general options on each level.
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  fields: [:name],
-                  display_name: :name,
-                  minimum_input_length: 0,
-                  level_1: {
-                    attribute: :country_id,
-                    minimum_input_length: 3,
-                    url: '/api/countries',
-                    response_root: 'paises'
-                  },
-                  level_2: {
-                    attribute: :region_id,
-                    display_name: :id,
-                  },
-                  level_3: {
-                    attribute: :city_id,
-                    fields: [:name, :information]
-                  }
+f.input :city, as: :nested_select,
+               fields: [:name],
+               display_name: :name,
+               minimum_input_length: 0,
+               level_1: {
+                 attribute: :country,
+                 minimum_input_length: 3,
+                 url: '/api/countries',
+                 response_root: 'paises'
+               },
+               level_2: {
+                 attribute: :region,
+                 display_name: :id,
+               },
+               level_3: {
+                 attribute: :city,
+                 fields: [:name, :information]
+               }
 ```
 
 > `response_root` is not valid as general configuration. You need to define this attribute by level.
@@ -135,16 +135,16 @@ f.input :city_id, as: :nested_select,
 If you are using ajax search, you can define custom filters. For example, if you have:
 
 ```ruby
-f.input :city_id, as: :nested_select,
-                  level_1: { attribute: :country_id },
-                  level_2: {
-                    attribute: :region_id,
-                    filters: { name_contains: "Cuy", id_gt: 22 }
-                  },
-                  level_3: { attribute: :city_id }
+f.input :city, as: :nested_select,
+               level_1: { attribute: :country },
+               level_2: {
+                 attribute: :region,
+                 filters: { name_contains: "Cuy", id_gt: 22 }
+               },
+               level_3: { attribute: :city }
 ```
 
-After select a country, the regions will be filtered by:
+After selecting a country, the regions will be filtered by:
 
 * The selected country id.
 * The text entered in the region's input.

docs/slim-select_search.md

@@ -5,7 +5,7 @@
 To enable Slim Select ajax search functionality you need to do the following:
 
 ```ruby
-  f.input :category_id, as: :search_select, url: admin_categories_path,
+  f.input :category, as: :search_select, url: admin_categories_path,
           fields: [:name, :description], display_name: 'name', minimum_input_length: 2,
           order_by: 'description_asc'
 ```
@@ -18,7 +18,7 @@ To use on filters you need to add `as: :search_select_filter` with same options.
 If you want to use url helpers, use a `proc` like on the example
 
 ```ruby
-  filter :category_id, as: :search_select_filter, url: proc { admin_categories_path },
+  filter :category, as: :search_select_filter, url: proc { admin_categories_path },
          fields: [:name, :description], display_name: 'name', minimum_input_length: 2,
          order_by: 'description_asc'
 ```
@@ -30,10 +30,10 @@ In case you need to filter with an attribute of another table you need to includ
          fields: [:name, :email], display_name: 'email', minimum_input_length: 2,
          order_by: 'description_asc', method_model: User
 ```
+Note that in this case you need to use the `id` instead of the name of the association, just like you would do in a normal filter that uses an attribute of an association.
 
 ### Options
 
-* `category_id`: Notice we're using the relation field name, not the relation itself, so you can't use `f.input :category`.
 * `url`: This is the URL where to get the results. This URL expects an activeadmin collection Url (like the index action) or anything that uses [ransack](https://github.com/activerecord-hackery/ransack) search gem.
 * `response_root`: **(optional)** If a request to `url` responds with root, you can indicate the name of that root with this attribute. By default, the gem will try to infer the root from url. For example: if `url` is `GET /admin/categories`, the root will be `categories`. If you have a rootless api, you don't need to worry about this attribute.
 * `fields`: an array of field names where to search for matches in the related model (`Category` in this example). If we give many fields, they will be searched with an OR condition.

lib/activeadmin_addons/support/input_base.rb

@@ -7,47 +7,5 @@ class InputBase < Formtastic::Inputs::StringInput
     include InputOptionsHandler
     include InputMethods
     include InputHtmlHelpers
-
-    def to_html
-      load_input_class
-      load_control_attributes
-      render_custom_input
-      if parts.any?
-        input_wrapping { parts_to_html }
-      else
-        super
-      end
-    end
-
-    def input_html_options
-      # maxwidth and size are added by Formtastic::Inputs::StringInput
-      # but according to the HTML standard these are not valid attributes
-      # on the inputs provided by this module
-      super.except(:maxlength, :size).merge(control_attributes)
-    end
-
-    def parts_to_html
-      parts.flatten.join("\n").html_safe
-    end
-
-    def load_input_class
-      load_class(self.class.to_s.underscore.dasherize)
-    end
-
-    def load_control_attributes
-      # Override on child classes if needed
-    end
-
-    def render_custom_input
-      # Override on child classes if needed
-    end
-
-    def parts
-      @parts ||= []
-    end
-
-    def concat(part)
-      parts << part
-    end
   end
 end