Framework integration / Rails / Indexing

Serializing models

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

The attribute method

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:

Copy 
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

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.

Copy 
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

Every Algolia record needs an objectID. By default, this gem uses your record’s id as the 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.

Copy 
1
2
3
4
5
6

class UniqUser < ActiveRecord::Base
  include AlgoliaSearch

  algoliasearch id: :uniq_email do
  end
end
Copy 
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

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

Adding coordinates to your records lets you search by location.

Copy 
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.

Copy 
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:

Copy 
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

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

Copy 
1
2
3
4
5
6
7

class Contact < ActiveRecord::Base
  include AlgoliaSearch

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

If you’re using Rails version 4, you need to add rails-html-sanitizer to your dependencies.

Copy 
1

gem 'rails-html-sanitizer'

UTF-8 encoding

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

Copy 
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

This option is compatible with Ruby version 1.9 or later.

Serialization with ActiveModelSerializers

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.

Copy 
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
Previous
Setup
Next
Indexing
Did you find this page helpful?