Framework integration / Rails / Indexing

By default, all model attributes are indexed. You can control what you index with the attribute method

The attribute method# A

The attribute method defines which model attributes to index.

  • If you pass one or more symbols, it calls the methods with the same name.
  • If you pass it a block, you can only use one symbol to define the attribute name. The block defines the value.

To keep your code as readable as possible:

  • attributes is an alias for attribute
  • You can call both methods multiple times

For example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch do
    # Sending 3 model attributes
    attributes :first_name, :last_name, :email
    # Sending a dynamic attribute defined by instance method
    attribute :full_name
    # Aliasing birth_date attribute to dob with shorthand block syntax
    attribute (:dob) { birth_date }
    # Nesting the company information for organization-sake
    attribute :company do
      { name: company_name, website: company_website }
    end
  end

  def full_name
    "#{first_name} #{last_name}"
  end
end

If you’re using dynamic attributes, you need to handle updates to those attributes manually. For more information, see Automatic updates.

The add_attribute method# A

You can use the add_attribute(s) method for indexing. It’s useful if you want to index all attributes from an item, but also add new attributes.

1
2
3
4
5
6
7
8
9
10
11
12
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch do
    # Since no +attribute+ were defined, all model attributes will be sent.
    # Plus the full_name attribute
    add_attribute :full_name do
      "#{first_name} #{last_name}"
    end
  end

end

Custom object IDs# A

Every Algolia record needs an objectID. By default, this gem uses Rails id as the Algolia objectID.

To use a custom ID, use the id option. Each objectID must be unique in the index, or your records might be overwritten or deleted by other models.

The id can be a model attribute or you can define your own attribute.

1
2
3
4
5
6
class UniqUser < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch id: :uniq_email do
  end
end
1
2
3
4
5
6
7
8
9
10
class UniqUser < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch id: :algolia_id do
  end

  def algolia_id
    "user_#{id}"
  end
end

Helpers# A

This gem comes with helpers for special Algolia attributes. To detect changes for these helpers, see tags and geoloc helpers.

Coordinates for geo search#

Adding coordinates to your records lets you search by location.

1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch do
    geoloc :latitude, :longitude
  end
end

Tags#

The _tags attributes is required for filtering by tags. You use any attribute for filtering if you configure it in the settings.

1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch do
    tags ['trusted']
  end
end

To create tags dynamically, use a block:

1
2
3
4
5
6
7
8
9
10
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch do
    tags do
      [first_name.blank? || last_name.blank? ? 'partial' : 'full',
      has_valid_email? ? 'valid_email' : 'invalid_email']
    end
  end
end

Sanitize HTML# A

To remove all HTML tags from your attributes, use the sanitize options.

1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch sanitize: true do
    attributes :name, :email, :company
  end
end

UTF-8 encoding# A

To make all your attributes UTF-8 encoded, use the force_utf8_encoding option.

1
2
3
4
5
6
7
class Contact < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch force_utf8_encoding: true do
    attributes :name, :email, :company
  end
end

Serialization with ActiveModelSerializers# A

You can use ActiveModelSerializers to extract all logic for creating your records into a separate class.

In the algoliasearch block, specify what class to use with use_serializer. If specified, all attribute(s) methods are ignored. You can still use add_attribute(s) and the tags or geoloc helpers.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
# post_serializer.rb
class PostSerializer < ActiveModel::Serializer
  attributes :id, :title, :text
  has_one :author
  has_many :comments
end

# author_serializer.rb
class AuthorSerializer < ActiveModel::Serializer
  attributes :id, :name
end

# comment_serializer.rb
class CommentSerializer < ActiveModel::Serializer
  attributes :text
  has_one :author
end

# post.rb
class Post
  has_one :author
  has_many :comments

  algoliasearch do
    use_serializer PostSerializer
    # Also combine the serialize result with
    # `add_attribute`, `tags` or `geoloc` if necessary
  end
end
Did you find this page helpful?