algoliasearch rails
3.0.1
Documentação • Fórum da comunidade • Stack Overflow • Relatar um bug • Perguntas frequentes • Suporte
Esta joia permite integrar facilmente a API Algolia Search ao seu ORM favorito. É baseado na gema algoliasearch-client-ruby. Rails 6.xe 7.x são suportados.
Você pode estar interessado no exemplo de aplicativo Ruby on Rails que fornece um preenchimento automático baseado em autocomplete.js e uma página de resultados de pesquisa instantânea baseada em InstantSearch.js : algoliasearch-rails-example.
Você pode encontrar a referência completa no site da Algolia.
Configurar
Uso
Opções
objectID personalizadoÍndices
Teste
Solução de problemas
gem install algoliasearch-rails Adicione a gema ao seu Gemfile :
gem "algoliasearch-rails"E corra:
bundle install Crie um novo arquivo config/initializers/algoliasearch.rb para configurar seu APPLICATION_ID e API_KEY .
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' }A gema é compatível com ActiveRecord, Mongoid e Sequel.
Você pode configurar vários limites de tempo limite definindo as seguintes opções no momento da inicialização:
AlgoliaSearch . configuration = {
application_id : 'YourApplicationID' ,
api_key : 'YourAPIKey' ,
} Esta jóia faz uso extensivo dos retornos de chamada do Rails para acionar as tarefas de indexação. Se você estiver usando métodos que ignoram os retornos de chamada after_validation , before_save ou after_commit , suas alterações não serão indexadas. Por exemplo: update_attribute não realiza verificações de validações, para realizar validações ao atualizar use update_attributes .
Todos os métodos injetados pelo módulo AlgoliaSearch são prefixados por algolia_ e alias aos nomes abreviados associados, se ainda não estiverem definidos.
Contact . algolia_reindex! # <=> Contact.reindex!
Contact . algolia_search ( "jon doe" ) # <=> Contact.search("jon doe") O código a seguir criará um índice Contact e adicionará recursos de pesquisa ao seu modelo Contact :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attributes :first_name , :last_name , :email
end
end Você pode especificar os atributos a serem enviados (aqui restringimos a :first_name, :last_name, :email ) ou não (nesse caso, todos os atributos são enviados).
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes will be sent
end
end Você também pode usar o método add_attribute , para enviar todos os atributos do modelo + os extras:
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# all attributes + extra_attr will be sent
add_attribute :extra_attr
end
def extra_attr
"extra_val"
end
end Fornecemos muitas maneiras de configurar seu índice, permitindo que você ajuste a relevância geral do índice. Os mais importantes são os atributos pesquisáveis e os atributos que refletem a popularidade do registro .
class Product < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# list of attribute used to build an Algolia record
attributes :title , :subtitle , :description , :likes_count , :seller_name
# the `searchableAttributes` (formerly known as attributesToIndex) setting defines the attributes
# you want to search in: here `title`, `subtitle` & `description`.
# You need to list them by order of importance. `description` is tagged as
# `unordered` to avoid taking the position of a match into account in that attribute.
searchableAttributes [ 'title' , 'subtitle' , 'unordered(description)' ]
# the `customRanking` setting defines the ranking criteria use to compare two matching
# records in case their text-relevance is equal. It should reflect your record popularity.
customRanking [ 'desc(likes_count)' ]
end
end Para indexar um modelo, basta chamar reindex na classe:
Product . reindexPara indexar todos os seus modelos, você pode fazer algo assim:
Rails . application . eager_load! # Ensure all models are loaded (required in development).
algolia_models = ActiveRecord :: Base . descendants . select { | model | model . respond_to? ( :reindex ) }
algolia_models . each ( & :reindex ) As implementações de pesquisa tradicionais tendem a ter lógica e funcionalidade de pesquisa no backend. Isso fazia sentido quando a experiência de pesquisa consistia em um usuário inserir uma consulta de pesquisa, executá-la e, em seguida, ser redirecionado para uma página de resultados de pesquisa.
A implementação da pesquisa no back-end não é mais necessária. Na verdade, na maioria dos casos, é prejudicial ao desempenho devido ao aumento da latência de rede e de processamento. É altamente recomendável usar nosso cliente JavaScript API emitindo todas as solicitações de pesquisa diretamente do navegador, dispositivo móvel ou cliente do usuário final. Isso reduzirá a latência geral da pesquisa e, ao mesmo tempo, descarregará seus servidores.
O cliente JS API faz parte do gem, basta requerer algolia/v3/algoliasearch.min em algum lugar do seu manifesto JavaScript, por exemplo em application.js se você estiver usando Rails 3.1+:
//= require algolia/v3/algoliasearch.minEntão, no seu código JavaScript você pode fazer:
var client = algoliasearch ( ApplicationID , Search - Only - API - Key ) ;
var index = client . initIndex ( 'YourIndexName' ) ;
index . search ( 'something' , { hitsPerPage : 10 , page : 0 } )
. then ( function searchDone ( content ) {
console . log ( content )
} )
. catch ( function searchFailure ( err ) {
console . error ( err ) ;
} ) ;Recentemente (março de 2015) lançamos uma nova versão (V3) do nosso cliente JavaScript, se você estava usando nossa versão anterior (V2), leia o guia de migração
Notas: Recomendamos o uso de nosso JavaScript API Client para realizar consultas diretamente do navegador do usuário final, sem passar pelo seu servidor.
Uma pesquisa retorna objetos compatíveis com ORM, recarregando-os do seu banco de dados. Recomendamos o uso de nosso JavaScript API Client para realizar consultas para diminuir a latência geral e descarregar seus servidores.
hits = Contact . search ( "jon doe" )
p hits
p hits . raw_answer # to get the original JSON raw answer Um atributo highlight_result é adicionado a cada objeto ORM:
hits [ 0 ] . highlight_result [ 'first_name' ] [ 'value' ]Se quiser recuperar a resposta JSON bruta da API, sem recarregar os objetos do banco de dados, você pode usar:
json_answer = Contact . raw_search ( "jon doe" )
p json_answer
p json_answer [ 'hits' ]
p json_answer [ 'facets' ] Os parâmetros de pesquisa podem ser especificados através das configurações do índice estaticamente em seu modelo ou dinamicamente no momento da pesquisa, especificando os parâmetros de pesquisa como segundo argumento do método search :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :first_name , :last_name , :email
# default search parameters stored in the index settings
minWordSizefor1Typo 4
minWordSizefor2Typos 8
hitsPerPage 42
end
end # dynamical search parameters
p Contact . raw_search ( 'jon doe' , { hitsPerPage : 5 , page : 2 } ) Mesmo que seja altamente recomendável realizar todas as operações de pesquisa (e, portanto, de paginação) do seu front-end usando JavaScript , oferecemos suporte a will_paginate e kaminari como back-end de paginação.
Para usar :will_paginate , especifique :pagination_backend como segue:
AlgoliaSearch . configuration = { application_id : 'YourApplicationID' , api_key : 'YourAPIKey' , pagination_backend : :will_paginate } Então, assim que você usar o método search , os resultados retornados serão um conjunto paginado:
# in your controller
@results = MyModel . search ( 'foo' , hitsPerPage : 10 )
# in your views
# if using will_paginate
<%= will_paginate @results %>
# if using kaminari
<%= paginate @results %> Use o método tags para adicionar tags ao seu registro:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
tags [ 'trusted' ]
end
endou usando valores dinâmicos:
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 No momento da consulta, especifique { tagFilters: 'tagvalue' } ou { tagFilters: ['tagvalue1', 'tagvalue2'] } como parâmetros de pesquisa para restringir o conjunto de resultados a tags específicas.
As facetas podem ser recuperadas chamando o método de facets extras da resposta da pesquisa.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the list of attributes available for faceting
attributesForFaceting [ :company , :zip_code ]
end
end hits = Contact . search ( 'jon doe' , { facets : '*' } )
p hits # ORM-compliant array of objects
p hits . facets # extra method added to retrieve facets
p hits . facets [ 'company' ] # facet values+count of facet 'company'
p hits . facets [ 'zip_code' ] # facet values+count of facet 'zip_code' raw_json = Contact . raw_search ( 'jon doe' , { facets : '*' } )
p raw_json [ 'facets' ] Você também pode pesquisar valores de faceta.
Product . search_for_facet_values ( 'category' , 'Headphones' ) # Array of {value, highlighted, count}Este método também pode aceitar qualquer parâmetro que uma consulta possa aceitar. Isso ajustará a pesquisa apenas para resultados que correspondam à consulta.
# Only sends back the categories containing red Apple products (and only counts those)
Product . search_for_facet_values ( 'category' , 'phone' , {
query : 'red' ,
filters : 'brand:Apple'
} ) # Array of phone categories linked to red Apple products Mais informações sobre distintos para agrupamento podem ser encontradas aqui.
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
# [...]
# specify the attribute to be used for distinguishing the records
# in this case the records will be grouped by company
attributeForDistinct "company"
end
end Use o método geoloc para localizar seu registro:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
geoloc :lat_attr , :lng_attr
end
end No momento da consulta, especifique { aroundLatLng: "37.33, -121.89", aroundRadius: 50000 } como parâmetros de pesquisa para restringir o conjunto de resultados a 50 km em torno de San Jose.
Cada vez que um registro é salvo, ele será indexado de forma assíncrona . Por outro lado, cada vez que um registro for destruído, ele será - de forma assíncrona - removido do índice. Isso significa que uma chamada de rede com a operação ADD/DELETE é enviada de forma síncrona para a API Algolia, mas então o mecanismo processará a operação de forma assíncrona (portanto, se você fizer uma pesquisa logo depois, os resultados podem não refletir ainda).
Você pode desativar a indexação automática e a remoção automática definindo as seguintes opções:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch auto_index : false , auto_remove : false do
attribute :first_name , :last_name , :email
end
end Você pode desativar temporariamente a indexação automática usando o escopo without_auto_index . Isso geralmente é usado por motivos de desempenho.
Contact . delete_all
Contact . without_auto_index do
1 . upto ( 10000 ) { Contact . create! attributes } # inside this block, auto indexing task will not run.
end
Contact . reindex! # will use batch operationsVocê pode configurar o processo de indexação e remoção automática para usar uma fila para executar essas operações em segundo plano. As filas ActiveJob (Rails >=4.2) são usadas por padrão, mas você pode definir seu próprio mecanismo de enfileiramento:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : true do # ActiveJob will be triggered using a `algoliasearch` queue
attribute :first_name , :last_name , :email
end
endSe você estiver executando atualizações e exclusões em segundo plano, uma exclusão de registro poderá ser confirmada em seu banco de dados antes da execução efetiva do trabalho. Portanto, se você carregasse o registro para removê-lo do banco de dados, seu ActiveRecord#find falharia com um RecordNotFound.
Neste caso você pode ignorar o carregamento do registro do ActiveRecord e apenas se comunicar diretamente com o índice:
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endSe você estiver usando o Sidekiq:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_sidekiq_worker do
attribute :first_name , :last_name , :email
end
def self . trigger_sidekiq_worker ( record , remove )
MySidekiqWorker . perform_async ( record . id , remove )
end
end
class MySidekiqWorker
def perform ( id , remove )
if remove
# the record has likely already been removed from your database so we cannot
# use ActiveRecord#find to load it
index = AlgoliaSearch . client . init_index ( "index_name" )
index . delete_object ( id )
else
# the record should be present
c = Contact . find ( id )
c . index!
end
end
endSe você estiver usando atrasado_job:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch enqueue : :trigger_delayed_job do
attribute :first_name , :last_name , :email
end
def self . trigger_delayed_job ( record , remove )
if remove
record . delay . remove_from_index!
else
record . delay . index!
end
end
end Você pode forçar a indexação e a remoção a serem síncronas (nesse caso a gem chamará o método wait_task para garantir que a operação foi levada em consideração assim que o método retornar) definindo a seguinte opção: (isto NÃO é recomendado, exceto para fins de teste )
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch synchronous : true do
attribute :first_name , :last_name , :email
end
end Por padrão, o nome do índice será o nome da classe, por exemplo, "Contato". Você pode personalizar o nome do índice usando a opção index_name :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch index_name : "MyCustomName" do
attribute :first_name , :last_name , :email
end
end Você pode adicionar o sufixo ao nome do índice com o ambiente Rails atual usando a seguinte opção:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do # index name will be "Contact_#{Rails.env}"
attribute :first_name , :last_name , :email
end
end Você pode usar um bloco para especificar um valor de atributo complexo
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
add_attribute :full_name2
end
def full_name2
" #{ first_name } #{ last_name } "
end
end Notas: Assim que você usa esse código para definir atributos extras, a gem não é mais capaz de detectar se o atributo mudou (o código usa o método #{attribute}_changed? do Rails para detectar isso). Como consequência, seu registro será enviado para a API mesmo que seus atributos não tenham sido alterados. Você pode contornar esse comportamento criando um _changed? método:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch do
attribute :email
attribute :full_name do
" #{ first_name } #{ last_name } "
end
end
def full_name_changed?
first_name_changed? || last_name_changed?
end
end Você pode incorporar facilmente objetos aninhados definindo um atributo extra que retorna qualquer objeto compatível com JSON (um array ou um hash ou uma combinação de ambos).
class Profile < ActiveRecord :: Base
include AlgoliaSearch
belongs_to :user
has_many :specializations
algoliasearch do
attribute :user do
# restrict the nested "user" object to its `name` + `email`
{ name : user . name , email : user . email }
end
attribute :public_specializations do
# build an array of public specialization (include only `title` and `another_attr`)
specializations . select { | s | s . public? } . map do | s |
{ title : s . title , another_attr : s . another_attr }
end
end
end
end Com o ActiveRecord, usaremos touch e after_touch para conseguir isso.
# app/models/app.rb
class App < ApplicationRecord
include AlgoliaSearch
belongs_to :author , class_name : :User
after_touch :index!
algoliasearch do
attribute :title
attribute :author do
author . as_json
end
end
end
# app/models/user.rb
class User < ApplicationRecord
# If your association uses belongs_to
# - use `touch: true`
# - do not define an `after_save` hook
has_many :apps , foreign_key : :author_id
after_save { apps . each ( & :touch ) }
end Com o Sequel, você pode usar o plugin touch para propagar as alterações:
# app/models/app.rb
class App < Sequel :: Model
include AlgoliaSearch
many_to_one :author , class : :User
plugin :timestamps
plugin :touch
algoliasearch do
attribute :title
attribute :author do
author . to_hash
end
end
end
# app/models/user.rb
class User < Sequel :: Model
one_to_many :apps , key : :author_id
plugin :timestamps
# Can't use the associations since it won't trigger the after_save
plugin :touch
# Define the associations that need to be touched here
# Less performant, but allows for the after_save hook to trigger
def touch_associations
apps . map ( & :touch )
end
def touch
super
touch_associations
end
end objectID personalizado Por padrão, o objectID é baseado no id do seu registro. Você pode alterar esse comportamento especificando a opção :id (certifique-se de usar um campo uniq).
class UniqUser < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch id : :uniq_name do
end
end Você pode adicionar restrições controlando se um registro deve ser indexado usando as opções :if ou :unless .
Ele permite que você faça indexação condicional por documento.
class Post < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published? , unless : :deleted? do
end
def published?
# [...]
end
def deleted?
# [...]
end
end Notas: Assim que você usar essas restrições, as chamadas addObjects e deleteObjects serão executadas para manter o índice sincronizado com o banco de dados (a gema sem estado não sabe se o objeto não corresponde mais às suas restrições ou nunca correspondeu , então forçamos o envio das operações ADD/DELETE). Você pode contornar esse comportamento criando um _changed? método:
class Contact < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch if : :published do
end
def published
# true or false
end
def published_changed?
# return true only if you know that the 'published' state changed
end
endVocê pode indexar um subconjunto de seus registros usando:
# will generate batch API calls (recommended)
MyModel . where ( 'updated_at > ?' , 10 . minutes . ago ) . reindex!ou
MyModel . index_objects MyModel . limit ( 5 ) Você pode higienizar todos os seus atributos usando a opção sanitize . Isso removerá todas as tags HTML dos seus atributos.
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , sanitize : true do
attributes :name , :email , :company
end
end Se você estiver usando Rails 4.2+, você também precisará depender de rails-html-sanitizer :
gem 'rails-html-sanitizer' Você pode forçar a codificação UTF-8 de todos os seus atributos usando a opção force_utf8_encoding :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch force_utf8_encoding : true do
attributes :name , :email , :company
end
endNotas: Esta opção não é compatível com Ruby 1.8
Você pode desabilitar exceções que podem ser levantadas ao tentar acessar a API do Algolia usando a opção raise_on_failure :
class Contact < ActiveRecord :: Base
include AlgoliaSearch
# only raise exceptions in development env
algoliasearch raise_on_failure : Rails . env . development? do
attribute :first_name , :last_name , :email
end
end Aqui está um exemplo de configuração de palavra real (do HN Search):
class Item < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true do
# the list of attributes sent to Algolia's API
attribute :created_at , :title , :url , :author , :points , :story_text , :comment_text , :author , :num_comments , :story_id , :story_title
# integer version of the created_at datetime field, to use numerical filtering
attribute :created_at_i do
created_at . to_i
end
# `title` is more important than `{story,comment}_text`, `{story,comment}_text` more than `url`, `url` more than `author`
# btw, do not take into account position in most fields to avoid first word match boost
searchableAttributes [ 'unordered(title)' , 'unordered(story_text)' , 'unordered(comment_text)' , 'unordered(url)' , 'author' ]
# tags used for filtering
tags do
[ item_type , "author_ #{ author } " , "story_ #{ story_id } " ]
end
# use associated number of HN points to sort results (last sort criteria)
customRanking [ 'desc(points)' , 'desc(num_comments)' ]
# google+, $1.5M raises, C#: we love you
separatorsToIndex '+#$'
end
def story_text
item_type_cd != Item . comment ? text : nil
end
def story_title
comment? && story ? story . title : nil
end
def story_url
comment? && story ? story . url : nil
end
def comment_text
comment? ? text : nil
end
def comment?
item_type_cd == Item . comment
end
# [...]
end Você pode acionar a indexação usando o index! método de instância.
c = Contact . create! ( params [ :contact ] )
c . index! E acione a remoção do índice usando remove_from_index! método de instância.
c . remove_from_index!
c . destroy A gema oferece 2 maneiras de reindexar todos os seus objetos:
Para reindexar todos os seus registros (levando em consideração os objetos excluídos), o método da classe reindex indexa todos os seus objetos para um índice temporário chamado <INDEX_NAME>.tmp e move o índice temporário para o final assim que tudo estiver indexado (atomicamente). Esta é a maneira mais segura de reindexar todo o seu conteúdo.
Contact . reindex Observações : se você estiver usando uma chave de API específica do índice, certifique-se de permitir <INDEX_NAME> e <INDEX_NAME>.tmp .
Aviso: você não deve usar essa operação de reindexação atômica ao definir o escopo/filtrar o modelo porque esta operação substitui o índice inteiro , mantendo apenas os objetos filtrados. ou seja: Não faça MyModel.where(...).reindex mas faça MyModel.where(...).reindex! (com o rastro ! )!!!
Para reindexar todos os seus objetos no lugar (sem índice temporário e, portanto, sem excluir objetos removidos), use o reindex! método de classe:
Contact . reindex! Para limpar um índice, use o clear_index! método de classe:
Contact . clear_index! Você pode acessar o objeto index subjacente chamando o método da classe de index :
index = Contact . index
# index.get_settings, index.partial_update_object, ... Você pode definir índices de réplica usando o método add_replica . Use inherit: true no bloco de réplica se quiser que ele herde das configurações primárias.
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch per_environment : true do
searchableAttributes [ :name , :author , :editor ]
# define a replica index to search by `author` only
add_replica 'Book_by_author' , per_environment : true do
searchableAttributes [ :author ]
end
# define a replica index with custom ordering but same settings than the main block
add_replica 'Book_custom_order' , inherit : true , per_environment : true do
customRanking [ 'asc(rank)' ]
end
end
endPara pesquisar usando uma réplica, use o seguinte código:
Book . raw_search 'foo bar' , replica : 'Book_by_editor'
# or
Book . search 'foo bar' , replica : 'Book_by_editor' Pode fazer sentido compartilhar um índice entre vários modelos. Para implementar isso, você precisará garantir que não haja nenhum conflito com o objectID dos modelos subjacentes.
class Student < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"student_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end
class Teacher < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
algoliasearch index_name : 'people' , id : :algolia_id do
# [...]
end
private
def algolia_id
"teacher_ #{ id } " # ensure the teacher & student IDs are not conflicting
end
end Notas: Se você segmentar um único índice de vários modelos, nunca deverá usar MyModel.reindex e apenas MyModel.reindex! . O método reindex utiliza um índice temporário para realizar uma reindexação atômica: se você utilizá-lo, o índice resultante conterá apenas registros do modelo atual porque não reindexará os demais.
Você pode indexar um registro em vários índices usando o método add_index :
class Book < ActiveRecord :: Base
attr_protected
include AlgoliaSearch
PUBLIC_INDEX_NAME = "Book_ #{ Rails . env } "
SECURED_INDEX_NAME = "SecuredBook_ #{ Rails . env } "
# store all books in index 'SECURED_INDEX_NAME'
algoliasearch index_name : SECURED_INDEX_NAME do
searchableAttributes [ :name , :author ]
# convert security to tags
tags do
[ released ? 'public' : 'private' , premium ? 'premium' : 'standard' ]
end
# store all 'public' (released and not premium) books in index 'PUBLIC_INDEX_NAME'
add_index PUBLIC_INDEX_NAME , if : :public? do
searchableAttributes [ :name , :author ]
end
end
private
def public?
released && ! premium
end
endPara pesquisar usando um índice extra, use o seguinte código:
Book . raw_search 'foo bar' , index : 'Book_by_editor'
# or
Book . search 'foo bar' , index : 'Book_by_editor' Para executar as especificações, defina as variáveis de ambiente ALGOLIA_APPLICATION_ID e ALGOLIA_API_KEY . Como os testes criam e removem índices, NÃO use sua conta de produção.
Você pode querer desabilitar todas as chamadas de API de indexação (operações de adição, atualização e exclusão). Você pode definir a opção disable_indexing :
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Rails . env . test? do
end
end
class User < ActiveRecord :: Base
include AlgoliaSearch
algoliasearch per_environment : true , disable_indexing : Proc . new { Rails . env . test? || more_complex_condition } do
end
end Encontrando um problema? Antes de entrar em contato com o suporte, recomendamos acessar nosso FAQ, onde você encontrará respostas para os problemas e pegadinhas mais comuns do cliente.
Se quiser contribuir com este projeto sem instalar todas as suas dependências, você pode usar nossa imagem Docker. Por favor, verifique nosso guia dedicado para saber mais.
