docs(readme-and-docs): change search and nested to use association name

Author: difernandez

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

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.