algoliasearch-rails 2.3.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f1f301750d7affc346eea8252c11e98722a8ac4c82be59fb8a248a69fa459ce
-  data.tar.gz: ce9e1536025efd0f881b6e45be3db203d7dc0eafc6f4b0d07cf8f9b8aea95761
+  metadata.gz: 29d7bf2701670f9e978131309e79791bf9ac674e3fe965d58bc3bb3e3e87eedb
+  data.tar.gz: 19da3705ecddadc270f3bfe923f93fe0336ba9b12b3fc459694c74f981330c9b
 SHA512:
-  metadata.gz: d9de7d8769fc9c19adbfbe70cef64e643c5d25d55774962d041962f570826566dd518a550fd23f73f4293bcdf5e1d048af354d2c9dc1c41ebe574dac64b5d996
-  data.tar.gz: '05787dce080a885c00ae4efdff6a9b4f26e2109979845ec8405d78f27f5c9757c30e77b814cb0f6957b49f8787cd468df15c8c8369091d80f39adc83e33f1adf'
+  metadata.gz: 5c14cccf9397ddc7058a74378c2706f4d2fe185fd1f31024906b4c9e42fc23c9843ad70fda5accdb94fe59c16f7dc5a2848acb39987a2bf77b48e1e4e3e68342
+  data.tar.gz: b0e6f450533fc19ee963640d5f0639ec07ce3dbbe369d015a12f5b31047473cbd878f93e16b853763a14821e95e8773d80c0aae2b36baa5b8b8ecbf7eed0fd13

data/CHANGELOG.MD

@@ -1,6 +1,10 @@
 # CHANGELOG
 
-## [Unreleased](https://github.com/algolia/algoliasearch-rails/compare/2.2.1...master)
+## [Unreleased](https://github.com/algolia/algoliasearch-rails/compare/3.0.0...master)
+
+## [3.0.0](https://github.com/algolia/algoliasearch-rails/compare/2.3.2...3.0.0)
+This new major version leverages the latest version of the Ruby Algolia API client. It also drops (official) support for Rails 5.x and Ruby versions older than 2.5
+For a list of known breaking changes, please refer to [the upgrade guide](./UPGRADING_TO_V3.MD)
 
 ## [2.3.2](https://github.com/algolia/algoliasearch-rails/compare/2.3.1...2.3.2)
 ### Added

data/Gemfile

@@ -1,7 +1,7 @@
 source "http://rubygems.org"
 
 gem 'json', '>= 1.5.1'
-gem 'algolia', '< 3.0.0'
+gem 'algolia', '>= 3.5.2'
 
 if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
   gem 'rubysl', '~> 2.0', :platform => :rbx
@@ -16,7 +16,7 @@ group :test do
   else
     gem 'sqlite3', '< 1.4.0', :platform => [:rbx, :ruby]
   end
-  gem 'rspec', '>= 2.5.0', '< 3.0'
+  gem 'rspec', '~> 3.0'
   gem 'jdbc-sqlite3', :platform => :jruby
   gem 'activerecord-jdbc-adapter', :platform => :jruby
   gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
@@ -27,7 +27,7 @@ group :test do
 end
 
 group :development do
-  gem 'rake', '~> 10.1.0'
+  gem 'rake', '>= 10.1.0'
   gem 'rdoc'
 end
 

data/Gemfile.lock

@@ -70,6 +70,7 @@ GEM
       faraday-net_http_persistent (>= 0.15, < 3)
       multi_json (~> 1.0)
       net-http-persistent
+    base64 (0.2.0)
     builder (3.2.4)
     case_transform (0.2)
       activesupport
@@ -77,15 +78,16 @@ GEM
     connection_pool (2.4.1)
     crass (1.0.6)
     date (3.3.3)
-    diff-lcs (1.5.0)
+    diff-lcs (1.5.1)
     erubi (1.12.0)
-    faraday (2.7.10)
+    faraday (2.8.1)
+      base64
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
     faraday-net_http (3.0.2)
-    faraday-net_http_persistent (2.1.0)
+    faraday-net_http_persistent (2.3.0)
       faraday (~> 2.5)
-      net-http-persistent (~> 4.0)
+      net-http-persistent (>= 4.0.4, < 5)
     globalid (1.1.0)
       activesupport (>= 5.0)
     i18n (1.14.1)
@@ -109,7 +111,7 @@ GEM
     mini_portile2 (2.8.4)
     minitest (5.19.0)
     multi_json (1.15.0)
-    net-http-persistent (4.0.2)
+    net-http-persistent (4.0.4)
       connection_pool (~> 2.2)
     net-imap (0.3.7)
       date
@@ -124,6 +126,7 @@ GEM
     nokogiri (1.13.10)
       mini_portile2 (~> 2.8.0)
       racc (~> 1.4)
+    pagy (6.5.0)
     psych (5.1.0)
       stringio
     racc (1.7.1)
@@ -201,6 +204,7 @@ DEPENDENCIES
   jdbc-sqlite3
   json (>= 1.5.1)
   kaminari (< 1)
+  pagy
   rails (~> 6.1)
   rake (~> 10.1.0)
   rdoc

data/README.md

@@ -26,7 +26,7 @@
 
 
 This gem let you easily integrate the Algolia Search API to your favorite ORM. It's based on the [algoliasearch-client-ruby](https://github.com/algolia/algoliasearch-client-ruby) gem.
-Rails 5.x and 6.x are supported.
+Rails 6.x and 7.x are supported.
 
 You might be interested in the sample Ruby on Rails application providing a `autocomplete.js`-based auto-completion and `InstantSearch.js`-based instant search results page: [algoliasearch-rails-example](https://github.com/algolia/algoliasearch-rails-example/).
 
@@ -128,11 +128,6 @@ You can configure a various timeout thresholds by setting the following options
 AlgoliaSearch.configuration = {
   application_id: 'YourApplicationID',
   api_key: 'YourAPIKey',
-  connect_timeout: 2,
-  receive_timeout: 30,
-  send_timeout: 30,
-  batch_timeout: 120,
-  search_timeout: 5
 }
 ```
 

data/algoliasearch-rails.gemspec

@@ -79,7 +79,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<json>, [">= 1.5.1"])
-      s.add_runtime_dependency(%q<algolia>, ["< 3.0.0"])
+      s.add_runtime_dependency(%q<algolia>, [">= 3.5.2"])
       s.add_development_dependency(%q<will_paginate>, [">= 2.3.15"])
       s.add_development_dependency(%q<kaminari>, [">= 0"])
       s.add_development_dependency(%q<pagy>, [">= 0"])
@@ -87,11 +87,11 @@ Gem::Specification.new do |s|
       s.add_development_dependency "rdoc"
     else
       s.add_dependency(%q<json>, [">= 1.5.1"])
-      s.add_dependency(%q<algolia>, ["< 3.0.0"])
+      s.add_dependency(%q<algolia>, [">= 3.5.2"])
     end
   else
     s.add_dependency(%q<json>, [">= 1.5.1"])
-    s.add_dependency(%q<algolia>, ["< 3.0.0"])
+    s.add_dependency(%q<algolia>, [">= 3.5.2"])
   end
 end
 

data/lib/algoliasearch/configuration.rb

@@ -1,10 +1,5 @@
 module AlgoliaSearch
   module Configuration
-    REQUIRED_CONFIGURATION = {
-      user_agent: "Algolia for Rails (#{AlgoliaSearch::VERSION}); Rails (#{defined?(::Rails::VERSION::STRING) ? ::Rails::VERSION::STRING : 'unknown'})",
-      symbolize_keys: false
-    }
-
     def initialize
       @client = nil
     end
@@ -14,19 +9,8 @@ module AlgoliaSearch
     end
 
     def configuration=(configuration)
-      user_agent = [REQUIRED_CONFIGURATION[:user_agent], configuration[:append_to_user_agent]].compact.join('; ')
       @@configuration = default_configuration
-                        .merge(configuration)
-                        .merge(REQUIRED_CONFIGURATION)
-                        .merge({ user_agent: user_agent })
-    end
-
-    def client_opts
-      @@opts ||= {}
-    end
-
-    def client_opts=(opts)
-      @@opts = opts
+                          .merge(configuration)
     end
 
     def client
@@ -38,7 +22,16 @@ module AlgoliaSearch
     end
 
     def setup_client
-      @client = Algolia::Search::Client.new(Algolia::Search::Config.new(@@configuration), client_opts)
+      @client = Algolia::SearchClient.create(
+        @@configuration[:application_id],
+        @@configuration[:api_key],
+        {
+          user_agent_segments: [
+            "Algolia for Rails (#{AlgoliaSearch::VERSION})",
+            "Rails (#{defined?(::Rails::VERSION::STRING) ? ::Rails::VERSION::STRING : 'unknown'})",
+            @@configuration[:append_to_user_agent]
+          ].compact
+        })
     end
 
     def default_configuration

data/lib/algoliasearch/pagination/pagy.rb

@@ -5,6 +5,7 @@ end
 module AlgoliaSearch
   module Pagination
     class Pagy
+
       def self.create(results, total_hits, options = {})
         vars = {
           count: total_hits,
@@ -12,7 +13,13 @@ module AlgoliaSearch
           items: options[:per_page]
         }
 
-        pagy = ::Pagy.new(vars)
+        pagy_version = Gem::Version.new(::Pagy::VERSION)
+        pagy = if pagy_version >= Gem::Version.new('9.0')
+                 ::Pagy.new(**vars)
+               else
+                 ::Pagy.new(vars)
+               end
+
         [pagy, results]
       end
     end

data/lib/algoliasearch/version.rb

@@ -1,3 +1,3 @@
 module AlgoliaSearch
-  VERSION = '2.3.2'
+  VERSION = '3.0.0'
 end

data/lib/algoliasearch-rails.rb

@@ -95,7 +95,6 @@ module AlgoliaSearch
 
     def use_serializer(serializer)
       @serializer = serializer
-      # instance_variable_set("@serializer", serializer)
     end
 
     def attribute(*names, &block)
@@ -177,16 +176,7 @@ module AlgoliaSearch
       end
 
       attributes.merge!(attributes_to_hash(@additional_attributes, object)) if @additional_attributes
-
-      if @options[:sanitize]
-        sanitizer = begin
-          ::HTML::FullSanitizer.new
-        rescue NameError
-          # from rails 4.2
-          ::Rails::Html::FullSanitizer.new
-        end
-        attributes = sanitize_attributes(attributes, sanitizer)
-      end
+      attributes = sanitize_attributes(attributes, Rails::Html::FullSanitizer.new) if @options[:sanitize]
 
       if @options[:force_utf8_encoding] && Object.const_defined?(:RUBY_VERSION) && RUBY_VERSION.to_f > 1.8
         attributes = encode_attributes(attributes)
@@ -241,10 +231,20 @@ module AlgoliaSearch
     end
 
     def to_settings
+      settings = to_hash
+
+      # Remove the synonyms setting since those need to be set separately
+      settings.delete(:synonyms)
+      settings.delete("synonyms")
+
+      Algolia::Search::IndexSettings.new(settings)
+    end
+
+    def to_hash
       settings = {}
       OPTIONS.each do |k|
         v = get_setting(k)
-        settings[k] = v if !v.nil?
+        settings[setting_name(k)] = v if !v.nil?
       end
 
       if !@options[:replica]
@@ -256,9 +256,18 @@ module AlgoliaSearch
         end
         settings.delete(:replicas) if settings[:replicas].empty?
       end
+
       settings
     end
 
+    def setting_name(name)
+      name.to_s.gsub(/::/, '/').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase
+    end
+
     def add_index(index_name, options = {}, &block)
       raise ArgumentError.new('Cannot specify additional index on a replica index') if @options[:replica]
       raise ArgumentError.new('No block given') if !block_given?
@@ -287,70 +296,6 @@ module AlgoliaSearch
     autoload :AlgoliaJob, 'algoliasearch/algolia_job'
   end
 
-  # this class wraps an Algolia::Index object ensuring all raised exceptions
-  # are correctly logged or thrown depending on the `raise_on_failure` option
-  class SafeIndex
-    def initialize(name, raise_on_failure)
-      @index = AlgoliaSearch.client.init_index(name)
-      @raise_on_failure = raise_on_failure.nil? || raise_on_failure
-    end
-
-    ::Algolia::Search::Index.instance_methods(false).each do |m|
-      define_method(m) do |*args, &block|
-        SafeIndex.log_or_throw(m, @raise_on_failure) do
-          @index.send(m, *args, &block)
-        end
-      end
-    end
-
-    # special handling of wait_task to handle null task_id
-    def wait_task(task_id)
-      return if task_id.nil? && !@raise_on_failure # ok
-      SafeIndex.log_or_throw(:wait_task, @raise_on_failure) do
-        @index.wait_task(task_id)
-      end
-    end
-
-    # special handling of get_settings to avoid raising errors on 404
-    def get_settings(*args)
-      SafeIndex.log_or_throw(:get_settings, @raise_on_failure) do
-        begin
-          @index.get_settings(*args)
-        rescue Algolia::AlgoliaHttpError => e
-          return {} if e.code == 404 # not fatal
-          raise e
-        end
-      end
-    end
-
-    # expose move as well
-    def self.move_index(old_name, new_name)
-      SafeIndex.log_or_throw(:move_index, true) do
-        AlgoliaSearch.client.move_index(old_name, new_name)
-      end
-    end
-
-    private
-    def self.log_or_throw(method, raise_on_failure, &block)
-      begin
-        yield
-      rescue Algolia::AlgoliaError => e
-        raise e if raise_on_failure
-        # log the error
-        (Rails.logger || Logger.new(STDOUT)).error("[algoliasearch-rails] #{e.message}")
-        # return something
-        case method.to_s
-        when 'search'
-          # some attributes are required
-          { 'hits' => [], 'hitsPerPage' => 0, 'page' => 0, 'facets' => {}, 'error' => e }
-        else
-          # empty answer
-          { 'error' => e }
-        end
-      end
-    end
-  end
-
   # these are the class methods added when AlgoliaSearch is included
   module ClassMethods
 
@@ -367,7 +312,6 @@ module AlgoliaSearch
         alias_method :raw_search, :algolia_raw_search unless method_defined? :raw_search
         alias_method :search_facet, :algolia_search_facet unless method_defined? :search_facet
         alias_method :search_for_facet_values, :algolia_search_for_facet_values unless method_defined? :search_for_facet_values
-        alias_method :index, :algolia_index unless method_defined? :index
         alias_method :index_name, :algolia_index_name unless method_defined? :index_name
         alias_method :must_reindex?, :algolia_must_reindex? unless method_defined? :must_reindex?
       end
@@ -497,7 +441,8 @@ module AlgoliaSearch
       return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
         next if options[:replica]
         last_task = nil
 
@@ -505,7 +450,7 @@ module AlgoliaSearch
           if algolia_conditional_index?(options)
             # delete non-indexable objects
             ids = group.select { |o| !algolia_indexable?(o, options) }.map { |o| algolia_object_id_of(o, options) }
-            index.delete_objects(ids.select { |id| !id.blank? })
+            AlgoliaSearch.client.delete_objects(index_name, ids.select { |id| !id.blank? })
             # select only indexable objects
             group = group.select { |o| algolia_indexable?(o, options) }
           end
@@ -516,9 +461,9 @@ module AlgoliaSearch
             end
             attributes.merge 'objectID' => algolia_object_id_of(o, options)
           end
-          last_task = index.save_objects(objects)
+          last_task = AlgoliaSearch.client.save_objects(index_name, objects).last.task_id
         end
-        index.wait_task(last_task.raw_response["taskID"]) if last_task and (synchronous || options[:synchronous])
+        AlgoliaSearch.client.wait_for_task(index_name, last_task) if last_task and (synchronous || options[:synchronous])
       end
       nil
     end
@@ -530,28 +475,30 @@ module AlgoliaSearch
         next if algolia_indexing_disabled?(options)
         next if options[:replica]
 
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+
         # fetch the master settings
-        master_index = algolia_ensure_init(options, settings)
-        master_settings = master_index.get_settings rescue {} # if master doesn't exist yet
+        master_settings = AlgoliaSearch.client.get_settings(index_name).to_hash rescue {} # if master doesn't exist yet
         master_exists = master_settings != {}
-        master_settings.merge!(JSON.parse(settings.to_settings.to_json)) # convert symbols to strings
+        master_settings.merge!(settings.to_hash)
 
         # remove the replicas of the temporary index
         master_settings.delete :replicas
         master_settings.delete 'replicas'
 
         # init temporary index
-        src_index_name = algolia_index_name(options)
-        tmp_index_name = "#{src_index_name}.tmp"
+        tmp_index_name = "#{index_name}.tmp"
         tmp_options = options.merge({ :index_name => tmp_index_name })
         tmp_options.delete(:per_environment) # already included in the temporary index_name
         tmp_settings = settings.dup
 
         if options[:check_settings] == false && master_exists
-          AlgoliaSearch.client.copy_index!(src_index_name, tmp_index_name, { scope: %w[settings synonyms rules] })
-          tmp_index = SafeIndex.new(tmp_index_name, !!options[:raise_on_failure])
-        else
-          tmp_index = algolia_ensure_init(tmp_options, tmp_settings, master_settings)
+          task_id = AlgoliaSearch.client.operation_index(
+            index_name,
+            Algolia::Search::OperationIndexParams.new(operation: Algolia::Search::OperationType::COPY, destination: tmp_index_name, scope: %w[settings synonyms rules])
+          ).task_id
+          AlgoliaSearch.client.wait_for_task(index_name, task_id)
         end
 
         algolia_find_in_batches(batch_size) do |group|
@@ -560,11 +507,15 @@ module AlgoliaSearch
             group = group.select { |o| algolia_indexable?(o, tmp_options) }
           end
           objects = group.map { |o| tmp_settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, tmp_options) }
-          tmp_index.save_objects(objects)
+
+          AlgoliaSearch.client.save_objects(tmp_index_name, objects)
         end
 
-        move_task = SafeIndex.move_index(tmp_index.name, src_index_name)
-        master_index.wait_task(move_task.raw_response["taskID"]) if synchronous || options[:synchronous]
+        task_id = AlgoliaSearch.client.operation_index(
+          tmp_index_name,
+          Algolia::Search::OperationIndexParams.new(operation: "move", destination: index_name)
+        ).task_id
+        AlgoliaSearch.client.wait_for_task(index_name, task_id) if synchronous || options[:synchronous]
       end
       nil
     end
@@ -572,27 +523,40 @@ module AlgoliaSearch
     def algolia_set_settings(synchronous = false)
       algolia_configurations.each do |options, settings|
         if options[:primary_settings] && options[:inherit]
-          primary = options[:primary_settings].to_settings
+          primary = options[:primary_settings].to_settings.to_hash
           primary.delete :replicas
           primary.delete 'replicas'
-          final_settings = primary.merge(settings.to_settings)
+          final_settings = primary.merge(settings.to_settings.to_hash)
         else
-          final_settings = settings.to_settings
+          final_settings = settings.to_settings.to_hash
         end
 
-        index = SafeIndex.new(algolia_index_name(options), true)
-        task = index.set_settings(final_settings)
-        index.wait_task(task.raw_response["taskID"]) if synchronous
+        s = final_settings.map do |k, v|
+          [settings.setting_name(k), v]
+        end.to_h
+
+        synonyms = s.delete("synonyms") || s.delete(:synonyms)
+        unless synonyms.nil? || synonyms.empty?
+          resp = AlgoliaSearch.client.save_synonyms(index_name,synonyms.map {|s| Algolia::Search::SynonymHit.new({object_id: s.join("-"), synonyms: s, type: "synonym"}) } )
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if synchronous || options[:synchronous]
+        end
+
+        resp = AlgoliaSearch.client.set_settings(index_name, Algolia::Search::IndexSettings.new(s))
+        AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if synchronous || options[:synchronous]
       end
     end
 
     def algolia_index_objects(objects, synchronous = false)
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+
         next if options[:replica]
-        task = index.save_objects(objects.map { |o| settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, options) })
-        index.wait_task(task.raw_response["taskID"]) if synchronous || options[:synchronous]
+        tasks = AlgoliaSearch.client.save_objects(index_name, objects.map { |o| settings.get_attributes(o).merge 'objectID' => algolia_object_id_of(o, options) })
+        tasks.each do |task|
+          AlgoliaSearch.client.wait_for_task(index_name, task.task_id) if synchronous || options[:synchronous]
+        end
       end
     end
 
@@ -600,22 +564,23 @@ module AlgoliaSearch
       return if algolia_without_auto_index_scope
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
+
         object_id = algolia_object_id_of(object, options)
-        index = algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+        algolia_ensure_init(options, settings)
         next if options[:replica]
+
         if algolia_indexable?(object, options)
           raise ArgumentError.new("Cannot index a record with a blank objectID") if object_id.blank?
+          resp = AlgoliaSearch.client.save_object(index_name, settings.get_attributes(object).merge({ 'objectID' => algolia_object_id_of(object, options) }))
           if synchronous || options[:synchronous]
-            index.save_object!(settings.get_attributes(object).merge 'objectID' => algolia_object_id_of(object, options))
-          else
-            index.save_object(settings.get_attributes(object).merge 'objectID' => algolia_object_id_of(object, options))
+            AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
           end
         elsif algolia_conditional_index?(options) && !object_id.blank?
           # remove non-indexable objects
+          resp = AlgoliaSearch.client.delete_object(index_name, object_id)
           if synchronous || options[:synchronous]
-            index.delete_object!(object_id)
-          else
-            index.delete_object(object_id)
+            AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
           end
         end
       end
@@ -628,12 +593,14 @@ module AlgoliaSearch
       raise ArgumentError.new("Cannot index a record with a blank objectID") if object_id.blank?
       algolia_configurations.each do |options, settings|
         next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+
         next if options[:replica]
+
+        resp = AlgoliaSearch.client.delete_object(index_name, object_id)
         if synchronous || options[:synchronous]
-          index.delete_object!(object_id)
-        else
-          index.delete_object(object_id)
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id)
         end
       end
       nil
@@ -641,22 +608,38 @@ module AlgoliaSearch
 
     def algolia_clear_index!(synchronous = false)
       algolia_configurations.each do |options, settings|
-        next if algolia_indexing_disabled?(options)
-        index = algolia_ensure_init(options, settings)
-        next if options[:replica]
-        synchronous || options[:synchronous] ? index.clear_objects! : index.clear_objects
-        @algolia_indexes[settings] = nil
+        next if algolia_indexing_disabled?(options) || options[:replica]
+
+        algolia_ensure_init(options, settings)
+        index_name = algolia_index_name(options)
+        res = AlgoliaSearch.client.clear_objects(index_name)
+
+        if synchronous || options[:synchronous]
+          AlgoliaSearch.client.wait_for_task(index_name, res.task_id)
+        end
       end
       nil
     end
 
+
     def algolia_raw_search(q, params = {})
-      index_name = params.delete(:index) ||
+      index_name_base = params.delete(:index) ||
                    params.delete('index') ||
                    params.delete(:replica) ||
                    params.delete('replica')
-      index = algolia_index(index_name)
-      index.search(q, Hash[params.map { |k,v| [k.to_s, v.to_s] }])
+
+      opts = algoliasearch_options
+      unless index_name_base.nil?
+        algolia_configurations.each do |o, s|
+          if o[:index_name].to_s == index_name_base.to_s
+            opts = o
+            ensure_algolia_index(index_name_base)
+          end
+        end
+      end
+
+      index_name = algolia_index_name(opts, index_name_base)
+      AlgoliaSearch.client.search_single_index(index_name,Hash[params.to_h.map { |k,v| [k.to_s, v.to_s] }].merge({query: q})).to_hash
     end
 
     module AdditionalMethods
@@ -672,7 +655,7 @@ module AlgoliaSearch
       end
 
       def algolia_facets
-        @algolia_json['facets']
+        @algolia_json[:facets]
       end
 
       private
@@ -688,7 +671,7 @@ module AlgoliaSearch
         params[:page] -= 1 if params[:page].to_i > 0
       end
       json = algolia_raw_search(q, params)
-      hit_ids = json['hits'].map { |hit| hit['objectID'] }
+      hit_ids = json[:hits].map { |hit| hit[:objectID] }
       if defined?(::Mongoid::Document) && self.include?(::Mongoid::Document)
         condition_key = algolia_object_id_method.in
       else
@@ -697,18 +680,18 @@ module AlgoliaSearch
       results_by_id = algoliasearch_options[:type].where(condition_key => hit_ids).index_by do |hit|
         algolia_object_id_of(hit)
       end
-      results = json['hits'].map do |hit|
-        o = results_by_id[hit['objectID'].to_s]
+      results = json[:hits].map do |hit|
+        o = results_by_id[hit[:objectID].to_s]
         if o
-          o.highlight_result = hit['_highlightResult']
-          o.snippet_result = hit['_snippetResult']
+          o.highlight_result = hit[:_highlightResult]
+          o.snippet_result = hit[:_snippetResult]
           o
         end
       end.compact
       # Algolia has a default limit of 1000 retrievable hits
-      total_hits = json['nbHits'].to_i < json['nbPages'].to_i * json['hitsPerPage'].to_i ?
-        json['nbHits'].to_i: json['nbPages'].to_i * json['hitsPerPage'].to_i
-      res = AlgoliaSearch::Pagination.create(results, total_hits, algoliasearch_options.merge({ :page => json['page'].to_i + 1, :per_page => json['hitsPerPage'] }))
+      total_hits = json[:nbHits].to_i < json[:nbPages].to_i * json[:hitsPerPage].to_i ?
+        json[:nbHits].to_i: json[:nbPages].to_i * json[:hitsPerPage].to_i
+      res = AlgoliaSearch::Pagination.create(results, total_hits, algoliasearch_options.merge({ :page => json[:page].to_i + 1, :per_page => json[:hitsPerPage] }))
       res.extend(AdditionalMethods)
       res.send(:algolia_init_raw_answer, json)
       res
@@ -719,15 +702,16 @@ module AlgoliaSearch
                    params.delete('index') ||
                    params.delete(:replica) ||
                    params.delete('replicas')
-      index = algolia_index(index_name)
-      query = Hash[params.map { |k, v| [k.to_s, v.to_s] }]
-      index.search_for_facet_values(facet, text, query)['facetHits']
+      index_name ||= algolia_index_name(algoliasearch_options)
+      req = Algolia::Search::SearchForFacetValuesRequest.new({facet_query: text, params: params.to_query})
+
+      AlgoliaSearch.client.search_for_facet_values(index_name, facet, req).facet_hits
     end
 
     # deprecated (renaming)
     alias :algolia_search_facet :algolia_search_for_facet_values
 
-    def algolia_index(name = nil)
+    def ensure_algolia_index(name = nil)
       if name
         algolia_configurations.each do |o, s|
           return algolia_ensure_init(o, s) if o[:index_name].to_s == name.to_s
@@ -737,9 +721,9 @@ module AlgoliaSearch
       algolia_ensure_init
     end
 
-    def algolia_index_name(options = nil)
+    def algolia_index_name(options = nil, index_name = nil)
       options ||= algoliasearch_options
-      name = options[:index_name] || model_name.to_s.gsub('::', '_')
+      name = index_name || options[:index_name] || model_name.to_s.gsub('::', '_')
       name = "#{name}_#{Rails.env.to_s}" if options[:per_environment]
       name
     end
@@ -774,36 +758,46 @@ module AlgoliaSearch
 
     protected
 
-    def algolia_ensure_init(options = nil, settings = nil, index_settings = nil)
+    def algolia_ensure_init(options = nil, settings = nil, index_settings_hash = nil)
       raise ArgumentError.new('No `algoliasearch` block found in your model.') if algoliasearch_settings.nil?
 
-      @algolia_indexes ||= {}
+      @algolia_indexes_init ||= {}
 
       options ||= algoliasearch_options
       settings ||= algoliasearch_settings
 
-      return @algolia_indexes[settings] if @algolia_indexes[settings]
+      return if @algolia_indexes_init[settings]
 
-      @algolia_indexes[settings] = SafeIndex.new(algolia_index_name(options), algoliasearch_options[:raise_on_failure])
+      index_name = algolia_index_name(options)
 
-      index_settings ||= settings.to_settings
-      index_settings = options[:primary_settings].to_settings.merge(index_settings) if options[:inherit]
-      replicas = index_settings.delete(:replicas) ||
-                 index_settings.delete('replicas')
-      index_settings[:replicas] = replicas unless replicas.nil? || options[:inherit]
+
+      index_settings_hash ||= settings.to_settings.to_hash
+      index_settings_hash = options[:primary_settings].to_settings.to_hash.merge(index_settings_hash) if options[:inherit]
+      replicas = index_settings_hash.delete(:replicas) || index_settings_hash.delete('replicas')
+      index_settings_hash[:replicas] = replicas unless replicas.nil? || options[:inherit]
 
       options[:check_settings] = true if options[:check_settings].nil?
 
       current_settings = if options[:check_settings] && !algolia_indexing_disabled?(options)
-                           @algolia_indexes[settings].get_settings(:getVersion => 1) rescue nil # if the index doesn't exist
+                           AlgoliaSearch.client.get_settings(index_name, {:getVersion => 1}).to_hash rescue nil # if the index doesn't exist
                          end
 
-      if !algolia_indexing_disabled?(options) && options[:check_settings] && algoliasearch_settings_changed?(current_settings, index_settings)
-        set_settings_method = options[:synchronous] ? :set_settings! : :set_settings
-        @algolia_indexes[settings].send(set_settings_method, index_settings)
+      if !algolia_indexing_disabled?(options) && options[:check_settings] && algoliasearch_settings_changed?(current_settings, index_settings_hash)
+        s = index_settings_hash.map do |k, v|
+          [settings.setting_name(k), v]
+        end.to_h
+
+        synonyms = s.delete("synonyms") || s.delete(:synonyms)
+        unless synonyms.nil? || synonyms.empty?
+          resp = AlgoliaSearch.client.save_synonyms(index_name,synonyms.map {|s| Algolia::Search::SynonymHit.new({object_id: s.join("-"), synonyms: s, type: "synonym"}) } )
+          AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if options[:synchronous]
+        end
+
+        resp = AlgoliaSearch.client.set_settings(index_name, Algolia::Search::IndexSettings.new(s))
+        AlgoliaSearch.client.wait_for_task(index_name, resp.task_id) if options[:synchronous]
       end
 
-      @algolia_indexes[settings]
+      return
     end
 
     private
@@ -843,7 +837,7 @@ module AlgoliaSearch
     def algoliasearch_settings_changed?(prev, current)
       return true if prev.nil?
       current.each do |k, v|
-        prev_v = prev[k.to_s]
+        prev_v = prev[k.to_sym] || prev[k.to_s]
         if v.is_a?(Array) and prev_v.is_a?(Array)
           # compare array of strings, avoiding symbols VS strings comparison
           return true if v.map { |x| x.to_s } != prev_v.map { |x| x.to_s }

data/spec/spec_helper.rb

@@ -32,8 +32,12 @@ RSpec.configure do |c|
   # Remove all indexes setup in this run in local or CI
   c.after(:suite) do
     safe_index_list.each do |i|
-      index = AlgoliaSearch.client.init_index(i['name'])
-      index.delete!
+      begin
+        res = AlgoliaSearch.client.delete_index(i.name)
+        AlgoliaSearch.client.wait_for_task(i.name, res.task_id)
+      rescue
+        # fail gracefully
+      end
     end
   end
 end
@@ -48,7 +52,7 @@ end
 
 # get a list of safe indexes in local or CI
 def safe_index_list
-  list = AlgoliaSearch.client.list_indexes['items']
-  list = list.select { |index| index["name"].include?(SAFE_INDEX_PREFIX) }
-  list.sort_by { |index| index["primary"] || "" }
+  list = AlgoliaSearch.client.list_indices.items
+  list = list.select { |index| index.name.include?(SAFE_INDEX_PREFIX) }
+  list.sort_by { |index| index.primary || "" }
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algoliasearch-rails
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Algolia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-03-19 00:00:00.000000000 Z
+date: 2024-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -28,16 +28,16 @@ dependencies:
   name: algolia
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.5.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.5.2
 - !ruby/object:Gem::Dependency
   name: will_paginate
   requirement: !ruby/object:Gem::Requirement
@@ -182,7 +182,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: AlgoliaSearch integration to your favorite ORM