algolia 2.0.4 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e2ba367e6308158bc455c60a0d0a5c16fbb1ed4565aaa3a6b8d4cca3e16f0c0d
-  data.tar.gz: af53995633ba454c929265d5d81d311c67a99fcdd76e8eeec51f98aa8e89f778
+  metadata.gz: dc743bd03ca6ebc94d2ae61eec22670ccbaa3531d2a9b66c44858280c644a938
+  data.tar.gz: 9e5fb85f9d474d266de360c25b7ef3efafa0fe0b78765aa1cae32b402a0865ac
 SHA512:
-  metadata.gz: 896b3821ad99f02449f652090c6b4249a932d454bd03e58879c2fad030d6179480b208c36bd07003dd3c58f96cd7630e28aa1afa026cc83f907a3bcf015f2f02
-  data.tar.gz: bdc286d0c8df062b33fc6d25fd6d3d4348dc82cce74703d26a12d8374a91c5e378e3d7f03ff2d617a76beab88828a8004d3457997394df2a9832277ca308f411
+  metadata.gz: b343a5a32c22f73fd18b33235e9dfd4adcc4c6f3236bac881ad37160dce5af9a7b79e836643ba126e3c0f2943d0187ffb804fe1688fdd6f9599966d39950fa48
+  data.tar.gz: 98fea72cc28767839cead8d54d75f9d2ac262999bb92b5ba446d81abfb9d43ef7986c99bccc523c892916df6cf605b3e5fcf305935161bf9bdf371ab24e44196

data/.circleci/config.yml

@@ -23,6 +23,13 @@ aliases:
     name: Run linting tool
     command: bundle exec rake rubocop
 
+  - &credentials
+    name: Retrieve temporary Algolia credentials if needed
+    command: |
+      if [ "$CIRCLE_PR_REPONAME" ]; then
+        curl -s https://algoliasearch-client-keygen.herokuapp.com | sh >> $BASH_ENV
+      fi
+
   - &run_tests
      name: Run unit and integration tests
      command: |
@@ -73,6 +80,7 @@ jobs:
       - restore_cache: *restore_cache
       - run: *install_bundler
       - save_cache: *save_cache
+      - run: *credentials
       - run: *run_tests
 
   test_jruby:
@@ -88,6 +96,7 @@ jobs:
       - restore_cache: *restore_cache
       - run: *install_bundler
       - save_cache: *save_cache
+      - run: *credentials
       - run: *run_tests
 
   release:

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # ChangeLog
 
-## [Unreleased](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.4...master)
+## [Unreleased](https://github.com/algolia/algoliasearch-client-ruby/compare/2.1.1..master)
+
+## [2.1.1](https://github.com/algolia/algoliasearch-client-ruby/compare/2.1.0...2.1.1) (2021-05-27)
+
+### Fix
+- Bug with read/write nodes caching ([`#455`](https://github.com/algolia/algoliasearch-client-ruby/pull/455))
+
+## [2.1.0](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.4...2.1.0) (2021-03-30)
+
+### Feat
+- Custom dictionaries methods
+
+### Fix
+- The parameter `forwardToReplicas` should be handled independently in the `set_settings` method
 
 ## [2.0.4](https://github.com/algolia/algoliasearch-client-ruby/compare/2.0.3...2.0.4) (2021-01-05)
 

data/lib/algolia.rb

@@ -20,6 +20,7 @@ require 'algolia/responses/indexing_response'
 require 'algolia/responses/add_api_key_response'
 require 'algolia/responses/update_api_key_response'
 require 'algolia/responses/delete_api_key_response'
+require 'algolia/responses/dictionary_response'
 require 'algolia/responses/restore_api_key_response'
 require 'algolia/responses/multiple_batch_indexing_response'
 require 'algolia/responses/multiple_response'

data/lib/algolia/helpers.rb

@@ -82,4 +82,53 @@ module Helpers
     end
     res
   end
+
+  # Check the passed object to determine if it's an array
+  #
+  # @param object [Object]
+  #
+  def check_array(object)
+    raise Algolia::AlgoliaError, 'argument must be an array of objects' unless object.is_a?(Array)
+  end
+
+  # Check the passed object
+  #
+  # @param object [Object]
+  # @param in_array [Boolean] whether the object is an array or not
+  #
+  def check_object(object, in_array = false)
+    case object
+    when Array
+      raise Algolia::AlgoliaError, in_array ? 'argument must be an array of objects' : 'argument must not be an array'
+    when String, Integer, Float, TrueClass, FalseClass, NilClass
+      raise Algolia::AlgoliaError, "argument must be an #{'array of' if in_array} object, got: #{object.inspect}"
+    end
+  end
+
+  # Check if passed object has a objectID
+  #
+  # @param object [Object]
+  # @param object_id [String]
+  #
+  def get_object_id(object, object_id = nil)
+    check_object(object)
+    object_id ||= object[:objectID] || object['objectID']
+    raise Algolia::AlgoliaError, "Missing 'objectID'" if object_id.nil?
+    object_id
+  end
+
+  # Build a batch request
+  #
+  # @param action [String] action to perform on the engine
+  # @param objects [Array] objects on which build the action
+  # @param with_object_id [Boolean] if set to true, check if each object has an objectID set
+  #
+  def chunk(action, objects, with_object_id = false)
+    objects.map do |object|
+      check_object(object, true)
+      request            = { action: action, body: object }
+      request[:objectID] = get_object_id(object).to_s if with_object_id
+      request
+    end
+  end
 end

data/lib/algolia/http/http_requester.rb

@@ -9,9 +9,9 @@ module Algolia
       # @param logger [Object] logger used to log requests. Defaults to Algolia::LoggerHelper
       #
       def initialize(adapter, logger)
-        @adapter    = adapter
-        @logger     = logger
-        @connection = nil
+        @adapter     = adapter
+        @logger      = logger
+        @connections = {}
       end
 
       # Sends request to the engine
@@ -65,7 +65,7 @@ module Algolia
       # @return [Faraday::Connection]
       #
       def connection(host)
-        @connection ||= Faraday.new(build_url(host)) do |f|
+        @connections[host.accept] ||= Faraday.new(build_url(host)) do |f|
           f.adapter @adapter.to_sym
         end
       end

data/lib/algolia/responses/dictionary_response.rb

@@ -0,0 +1,33 @@
+module Algolia
+  class DictionaryResponse < BaseResponse
+    include CallType
+
+    attr_reader :raw_response
+
+    # @param client [Search::Client] Algolia Search Client used for verification
+    # @param response [Hash] Raw response from the client
+    #
+    def initialize(client, response)
+      @client       = client
+      @raw_response = response
+      @done         = false
+    end
+
+    # Wait for the task to complete
+    #
+    # @param opts [Hash] contains extra parameters to send with your query
+    #
+    def wait(_opts = {})
+      until @done
+        res    = @client.custom_request({}, path_encode('/1/task/%s', @raw_response[:taskID]), :GET, READ)
+        status = get_option(res, 'status')
+        if status == 'published'
+          @done = true
+        end
+        sleep(Defaults::WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY / 1000)
+      end
+
+      self
+    end
+  end
+end

data/lib/algolia/search_client.rb

@@ -80,7 +80,7 @@ module Algolia
       end
 
       # # # # # # # # # # # # # # # # # # # # #
-      # MISC
+      # INDEX METHODS
       # # # # # # # # # # # # # # # # # # # # #
 
       # Initialize an index with a given name
@@ -594,12 +594,185 @@ module Algolia
         @transporter.read(:GET, '/1/clusters/mapping/pending' + handle_params({ getClusters: retrieve_mappings }), {}, request_options)
       end
 
-      #
       # Aliases the pending_mappings? method
       #
       alias_method :has_pending_mappings, :pending_mappings?
 
+      # # # # # # # # # # # # # # # # # # # # #
+      # CUSTOM DICTIONARIES METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
+      # Save entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def save_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Save entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def save_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = save_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Replace entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def replace_dictionary_entries(dictionary, dictionary_entries, opts = {})
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: true, requests: chunk('addEntry', dictionary_entries) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Replace entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param dictionary_entries [Array<Hash>] array of dictionary entries
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def replace_dictionary_entries!(dictionary, dictionary_entries, opts = {})
+        response = replace_dictionary_entries(dictionary, dictionary_entries, opts)
+
+        response.wait(opts)
+      end
+
+      # Delete entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def delete_dictionary_entries(dictionary, object_ids, opts = {})
+        request  = object_ids.map do |object_id|
+          { objectID: object_id }
+        end
+        response = @transporter.write(
+          :POST,
+          path_encode('/1/dictionaries/%s/batch', dictionary),
+          { clearExistingDictionaryEntries: false, requests: chunk('deleteEntry', request) },
+          opts
+        )
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Delete entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param object_ids [Array<Hash>] array of object ids
+      # @param opts [Hash] contains extra parameters to send with your query
       #
+      def delete_dictionary_entries!(dictionary, object_ids, opts = {})
+        response = delete_dictionary_entries(dictionary, object_ids, opts)
+
+        response.wait(opts)
+      end
+
+      # Clear all entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def clear_dictionary_entries(dictionary, opts = {})
+        replace_dictionary_entries(dictionary, [], opts)
+      end
+
+      # Clear all entries for a given dictionary and wait for the task to finish
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def clear_dictionary_entries!(dictionary, opts = {})
+        response = replace_dictionary_entries(dictionary, [], opts)
+
+        response.wait(opts)
+      end
+
+      # Search entries for a given dictionary
+      #
+      # @param dictionary [String] dictionary name. Can be either 'stopwords', 'plurals' or 'compounds'
+      # @param query [String] query to send
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def search_dictionary_entries(dictionary, query, opts = {})
+        @transporter.read(
+          :POST,
+          path_encode('/1/dictionaries/%s/search', dictionary),
+          { query: query },
+          opts
+        )
+      end
+
+      # Set settings for all the dictionaries
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings(dictionary_settings, opts = {})
+        response = @transporter.write(:PUT, '/1/dictionaries/*/settings', dictionary_settings, opts)
+
+        DictionaryResponse.new(self, response)
+      end
+
+      # Set settings for all the dictionaries and wait for the task to finish
+      #
+      # @param dictionary_settings [Hash]
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      # @return DictionaryResponse
+      #
+      def set_dictionary_settings!(dictionary_settings, opts = {})
+        response = set_dictionary_settings(dictionary_settings, opts)
+
+        response.wait(opts)
+      end
+
+      # Retrieve settings for all the dictionaries
+      #
+      # @param opts [Hash] contains extra parameters to send with your query
+      #
+      def get_dictionary_settings(opts = {})
+        @transporter.read(:GET, '/1/dictionaries/*/settings', {}, opts)
+      end
+
+      # # # # # # # # # # # # # # # # # # # # #
+      # MISC METHODS
+      # # # # # # # # # # # # # # # # # # # # #
+
       # Method available to make custom requests to the API
       #
       def custom_request(data, uri, method, call_type, opts = {})

data/lib/algolia/search_index.rb

@@ -987,7 +987,15 @@ module Algolia
       # @return [IndexingResponse]
       #
       def set_settings(settings, opts = {})
-        response = @transporter.write(:PUT, path_encode('/1/indexes/%s/settings', @name), settings, opts)
+        request_options      = symbolize_hash(opts)
+        forward_to_replicas  = request_options.delete(:forwardToReplicas) || false
+
+        response = @transporter.write(
+          :PUT,
+          path_encode('/1/indexes/%s/settings', @name) + handle_params({ forwardToReplicas: forward_to_replicas }),
+          settings,
+          request_options
+        )
 
         IndexingResponse.new(self, response)
       end
@@ -1037,55 +1045,6 @@ module Algolia
 
       private
 
-      # Check the passed object to determine if it's an array
-      #
-      # @param object [Object]
-      #
-      def check_array(object)
-        raise AlgoliaError, 'argument must be an array of objects' unless object.is_a?(Array)
-      end
-
-      # Check the passed object
-      #
-      # @param object [Object]
-      # @param in_array [Boolean] whether the object is an array or not
-      #
-      def check_object(object, in_array = false)
-        case object
-        when Array
-          raise AlgoliaError, in_array ? 'argument must be an array of objects' : 'argument must not be an array'
-        when String, Integer, Float, TrueClass, FalseClass, NilClass
-          raise AlgoliaError, "argument must be an #{'array of' if in_array} object, got: #{object.inspect}"
-        end
-      end
-
-      # Check if passed object has a objectID
-      #
-      # @param object [Object]
-      # @param object_id [String]
-      #
-      def get_object_id(object, object_id = nil)
-        check_object(object)
-        object_id ||= object[:objectID] || object['objectID']
-        raise AlgoliaError, "Missing 'objectID'" if object_id.nil?
-        object_id
-      end
-
-      # Build a batch request
-      #
-      # @param action [String] action to perform on the engine
-      # @param objects [Array] objects on which build the action
-      # @param with_object_id [Boolean] if set to true, check if each object has an objectID set
-      #
-      def chunk(action, objects, with_object_id = false)
-        objects.map do |object|
-            check_object(object, true)
-            request            = { action: action, body: object }
-            request[:objectID] = get_object_id(object).to_s if with_object_id
-            request
-        end
-      end
-
       def raw_batch(requests, opts)
         @transporter.write(:POST, path_encode('/1/indexes/%s/batch', @name), { requests: requests }, opts)
       end

data/lib/algolia/version.rb

@@ -1,3 +1,3 @@
 module Algolia
-  VERSION = '2.0.4'.freeze
+  VERSION = '2.1.1'.freeze
 end

data/test/algolia/integration/analytics_client_test.rb

@@ -23,7 +23,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index1.wait_task(response[:taskID])
@@ -86,7 +88,9 @@ class AnalyticsClientTest < BaseTest
         endAt: tomorrow.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
 
-      response   = client.add_ab_test(ab_test)
+      response   = retry_test do
+        client.add_ab_test(ab_test)
+      end
       ab_test_id = response[:abTestID]
 
       index.wait_task(response[:taskID])

data/test/algolia/integration/search_client_test.rb

@@ -1,3 +1,4 @@
+require 'securerandom'
 require_relative 'base_test'
 
 class SearchClientTest < BaseTest
@@ -223,7 +224,9 @@ class SearchClientTest < BaseTest
       assert_includes api_keys, @api_key[:value]
 
       @@search_client.update_api_key!(@api_key[:value], { maxHitsPerQuery: 42 })
-      updated_api_key = @@search_client.get_api_key(@api_key[:value])
+      updated_api_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value], test: 'test')
+      end
       assert_equal 42, updated_api_key[:maxHitsPerQuery]
 
       @@search_client.delete_api_key!(@api_key[:value])
@@ -234,18 +237,13 @@ class SearchClientTest < BaseTest
 
       assert_equal 'Key does not exist', exception.message
 
-      loop do
-        begin
-          @@search_client.restore_api_key!(@api_key[:value])
-          break
-        rescue Algolia::AlgoliaHttpError => e
-          if e.code != 404
-            raise StandardError
-          end
-        end
+      retry_test do
+        @@search_client.restore_api_key!(@api_key[:value])
       end
 
-      restored_key = @@search_client.get_api_key(@api_key[:value])
+      restored_key = retry_test do
+        @@search_client.get_api_key(@api_key[:value])
+      end
 
       refute_nil restored_key
     end
@@ -334,7 +332,12 @@ class SearchClientTest < BaseTest
         secured_index1 = secured_client.init_index(@index1.name)
         secured_index2 = secured_client.init_index(@index2.name)
 
-        secured_index1.search('')
+        res = retry_test do
+          secured_index1.search('')
+        end
+
+        assert_equal 1, res[:hits].length
+
         exception = assert_raises Algolia::AlgoliaHttpError do
           secured_index2.search('')
         end
@@ -367,5 +370,96 @@ class SearchClientTest < BaseTest
         assert_equal 'The SecuredAPIKey doesn\'t have a validUntil parameter.', exception.message
       end
     end
+
+    describe 'Custom Dictionaries' do
+      def before_all
+        @client = Algolia::Search::Client.create(APPLICATION_ID_2, ADMIN_KEY_2)
+      end
+
+      def test_stopwords_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'en',
+          word: 'down'
+        }
+        @client.save_dictionary_entries!('stopwords', [entry])
+
+        stopwords = @client.search_dictionary_entries('stopwords', entry_id)
+        assert_equal 1, stopwords[:nbHits]
+        assert_equal stopwords[:hits][0][:objectID], entry[:objectID]
+        assert_equal stopwords[:hits][0][:word], entry[:word]
+
+        @client.delete_dictionary_entries!('stopwords', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        old_dictionary_state   = @client.search_dictionary_entries('stopwords', '')
+        old_dictionary_entries = old_dictionary_state[:hits].map do |hit|
+          hit.reject { |key| key == :type }
+        end
+
+        @client.save_dictionary_entries!('stopwords', [entry])
+        assert_equal 1, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        @client.replace_dictionary_entries!('stopwords', old_dictionary_entries)
+        assert_equal 0, @client.search_dictionary_entries('stopwords', entry_id)[:nbHits]
+
+        stopwords_settings = {
+          disableStandardEntries: {
+            stopwords: {
+              en: true
+            }
+          }
+        }
+
+        @client.set_dictionary_settings!(stopwords_settings)
+
+        assert_equal @client.get_dictionary_settings, stopwords_settings
+      end
+
+      def test_plurals_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'fr',
+          words: %w(cheval chevaux)
+        }
+        @client.save_dictionary_entries!('plurals', [entry])
+
+        plurals = @client.search_dictionary_entries('plurals', entry_id)
+        assert_equal 1, plurals[:nbHits]
+        assert_equal plurals[:hits][0][:objectID], entry[:objectID]
+        assert_equal plurals[:hits][0][:words], entry[:words]
+
+        @client.delete_dictionary_entries!('plurals', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('plurals', entry_id)[:nbHits]
+      end
+
+      def test_compounds_dictionaries
+        entry_id = SecureRandom.hex
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+
+        entry = {
+          objectID: entry_id,
+          language: 'de',
+          word: 'kopfschmerztablette',
+          decomposition: %w(kopf schmerz tablette)
+        }
+        @client.save_dictionary_entries!('compounds', [entry])
+
+        compounds = @client.search_dictionary_entries('compounds', entry_id)
+        assert_equal 1, compounds[:nbHits]
+        assert_equal compounds[:hits][0][:objectID], entry[:objectID]
+        assert_equal compounds[:hits][0][:word], entry[:word]
+        assert_equal compounds[:hits][0][:decomposition], entry[:decomposition]
+
+        @client.delete_dictionary_entries!('compounds', [entry_id])
+        assert_equal 0, @client.search_dictionary_entries('compounds', entry_id)[:nbHits]
+      end
+    end
   end
 end

data/test/algolia/integration/search_index_test.rb

@@ -274,6 +274,9 @@ class SearchIndexTest < BaseTest
       @index.set_settings!(settings)
 
       assert_equal @index.get_settings, settings
+
+      # check that the forwardToReplicas parameter is passed correctly
+      assert @index.set_settings!(settings, { forwardToReplicas: true })
     end
   end
 

data/test/test_helper.rb

@@ -87,3 +87,15 @@ def rule_without_metadata(rule)
   rule.delete(:_metadata)
   rule
 end
+
+def retry_test(delay = 0.1, max_retries = 30)
+  (1...max_retries).each do |i|
+    begin
+      return yield
+    rescue Algolia::AlgoliaHttpError
+      sleep delay * i
+    end
+  end
+
+  raise StandardError, 'reached the maximum number of retries'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: algolia
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.1
 platform: ruby
 authors:
 - Algolia
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -238,6 +238,7 @@ files:
 - lib/algolia/responses/add_api_key_response.rb
 - lib/algolia/responses/base_response.rb
 - lib/algolia/responses/delete_api_key_response.rb
+- lib/algolia/responses/dictionary_response.rb
 - lib/algolia/responses/indexing_response.rb
 - lib/algolia/responses/multiple_batch_indexing_response.rb
 - lib/algolia/responses/multiple_response.rb
@@ -304,7 +305,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.6
 signing_key:
 specification_version: 4
 summary: A simple Ruby client for the algolia.com REST API