algolia 2.0.0.pre.alpha.2

data/test/algolia/unit/helpers_test.rb

@@ -0,0 +1,69 @@
+require 'algolia'
+require 'test_helper'
+
+class HelpersTest
+  include Helpers
+
+  describe 'test helpers' do
+    def test_deserialize_settings
+      old_settings = {
+        attributesToIndex: %w(attr1 attr2),
+        numericAttributesToIndex: %w(attr1 attr2),
+        slaves: %w(index1 index2)
+      }
+
+      new_settings = {
+        searchableAttributes: %w(attr1 attr2),
+        numericAttributesForFiltering: %w(attr1 attr2),
+        replicas: %w(index1 index2)
+      }
+
+      deserialized_settings = deserialize_settings(old_settings)
+      assert_equal new_settings, deserialized_settings
+    end
+  end
+
+  describe 'test hash_includes_subset' do
+    def test_empty_hashes
+      h      = {}
+      subset = {}
+      assert hash_includes_subset?(h, subset)
+    end
+
+    def test_with_empty_subset
+      h      = { a: 100, b: 200 }
+      subset = {}
+      assert hash_includes_subset?(h, subset)
+    end
+
+    def test_subset_included
+      h      = { a: 100, b: 200 }
+      subset = { a: 100 }
+      assert hash_includes_subset?(h, subset)
+    end
+
+    def test_subset_not_included
+      h      = { a: 100, b: 200 }
+      subset = { c: 300 }
+      refute hash_includes_subset?(h, subset)
+    end
+
+    def test_subset_included_but_wrong_value
+      h      = { a: 100, b: 200 }
+      subset = { a: 200 }
+      refute hash_includes_subset?(h, subset)
+    end
+
+    def test_subset_included_with_multiple_values
+      h      = { a: 100, b: 200, c: 300 }
+      subset = { a: 100, b: 200 }
+      assert hash_includes_subset?(h, subset)
+    end
+
+    def test_subset_not_included_because_too_many_values
+      h      = { a: 100, b: 200 }
+      subset = { a: 100, b: 200, c: 300 }
+      refute hash_includes_subset?(h, subset)
+    end
+  end
+end

data/test/algolia/unit/retry_strategy_test.rb

@@ -0,0 +1,139 @@
+require 'algolia'
+require 'test_helper'
+
+class RetryStrategyTest
+  include RetryOutcomeType
+  include CallType
+  describe 'get tryable hosts' do
+    def before_all
+      super
+      @app_id        = 'app_id'
+      @api_key       = 'api_key'
+      stateful_hosts = []
+      stateful_hosts << "#{@app_id}-4.algolianet.com"
+      stateful_hosts << "#{@app_id}-5.algolianet.com"
+      stateful_hosts << "#{@app_id}-6.algolianet.com"
+      @config        = Algolia::Search::Config.new(app_id: @app_id, api_key: @api_key, custom_hosts: stateful_hosts)
+    end
+
+    def test_resets_expired_hosts_according_to_read_type
+      @config.default_hosts[1].up = false
+      retry_strategy              = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(READ)
+      assert_equal 2, hosts.length
+    end
+
+    def test_resets_expired_hosts_according_to_write_type
+      @config.default_hosts[1].up = false
+      retry_strategy              = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(WRITE)
+      assert_equal 2, hosts.length
+    end
+
+    def test_resets_expired_hosts_according_to_read_type_with_timeout
+      @config.default_hosts[1].up       = false
+      @config.default_hosts[1].last_use = Time.new.utc - 1000
+      retry_strategy                    = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(READ)
+      assert_equal 3, hosts.length
+    end
+
+    def test_resets_expired_hosts_according_to_write_type_with_timeout
+      @config.default_hosts[1].up       = false
+      @config.default_hosts[1].last_use = Time.new.utc - 1000
+      retry_strategy                    = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(WRITE)
+      assert_equal 3, hosts.length
+    end
+
+    def test_resets_all_hosts_when_expired_according_to_read_type
+      0.upto(2).map do |i|
+        @config.default_hosts[i].up = false
+      end
+      retry_strategy        = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(READ)
+      assert_equal 3, hosts.length
+    end
+
+    def test_resets_all_hosts_when_expired_according_to_write_type
+      0.upto(2).map do |i|
+        @config.default_hosts[i].up = false
+      end
+      retry_strategy        = Algolia::Transport::RetryStrategy.new(@config)
+
+      hosts = retry_strategy.get_tryable_hosts(WRITE)
+      assert_equal 3, hosts.length
+    end
+  end
+
+  describe 'All hosts are unreachable' do
+    def test_failure_when_all_hosts_are_down
+      stateful_hosts = ['0.0.0.0']
+      @config        = Algolia::Search::Config.new(app_id: 'foo', api_key: 'bar', custom_hosts: stateful_hosts)
+      client         = Algolia::Search::Client.create_with_config(@config)
+      index          = client.init_index(get_test_index_name('failure'))
+
+      exception = assert_raises Algolia::AlgoliaUnreachableHostError do
+        index.save_object({ objectID: 'one' })
+      end
+
+      assert_equal 'Unreachable hosts', exception.message
+    end
+  end
+
+  describe 'retry stategy decisions' do
+    def before_all
+      super
+      @app_id         = 'app_id'
+      @api_key        = 'api_key'
+      @config         = Algolia::Search::Config.new(app_id: @app_id, api_key: @api_key)
+      @retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+      @hosts          = @retry_strategy.get_tryable_hosts(READ|WRITE)
+    end
+
+    def test_retry_decision_on_300
+      decision = @retry_strategy.decide(@hosts.first, http_response_code: 300)
+      assert_equal RETRY, decision
+    end
+
+    def test_retry_decision_on_500
+      retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+
+      decision = retry_strategy.decide(@hosts.first, http_response_code: 500)
+      assert_equal RETRY, decision
+    end
+
+    def test_retry_decision_on_timed_out
+      retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+
+      decision = retry_strategy.decide(@hosts.first, is_timed_out: true)
+      assert_equal RETRY, decision
+    end
+
+    def test_retry_decision_on_400
+      retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+
+      decision = retry_strategy.decide(@hosts.first, http_response_code: 400)
+      assert_equal FAILURE, decision
+    end
+
+    def test_retry_decision_on_404
+      retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+
+      decision = retry_strategy.decide(@hosts.first, http_response_code: 404)
+      assert_equal FAILURE, decision
+    end
+
+    def test_retry_decision_on_200
+      retry_strategy = Algolia::Transport::RetryStrategy.new(@config)
+
+      decision = retry_strategy.decide(@hosts.first, http_response_code: 200)
+      assert_equal SUCCESS, decision
+    end
+  end
+end

data/test/algolia/unit/user_agent_test.rb

@@ -0,0 +1,16 @@
+require 'algolia'
+require 'test_helper'
+
+class UserAgentTest
+  describe 'define user agent' do
+    def before_all
+      @default = "Algolia for Ruby (#{Algolia::VERSION}), Ruby (#{RUBY_VERSION})"
+    end
+
+    def test_add_user_agents
+      Algolia::UserAgent.add('Foo Bar', 'v1.0')
+      Algolia::UserAgent.add('Front Web', '2.0')
+      assert_equal(format('%<default>s; Foo Bar (v1.0); Front Web (2.0)', default: @default), Algolia::UserAgent.value)
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,89 @@
+require 'simplecov'
+
+if ENV['COVERAGE']
+  SimpleCov.start
+end
+
+require 'bundler/setup'
+require 'algolia'
+require 'minitest/autorun'
+require 'minitest/hooks'
+require 'algolia/integration/mocks/mock_requester'
+
+APPLICATION_ID_1   = ENV['ALGOLIA_APPLICATION_ID_1']
+ADMIN_KEY_1        = ENV['ALGOLIA_ADMIN_KEY_1']
+SEARCH_KEY_1       = ENV['ALGOLIA_SEARCH_KEY_1']
+APPLICATION_ID_2   = ENV['ALGOLIA_APPLICATION_ID_2']
+ADMIN_KEY_2        = ENV['ALGOLIA_ADMIN_KEY_2']
+MCM_APPLICATION_ID = ENV['ALGOLIA_APPLICATION_ID_MCM']
+MCM_ADMIN_KEY      = ENV['ALGOLIA_ADMIN_KEY_MCM']
+USER_AGENT         = 'test-ruby'
+
+class Minitest::Test
+  attr_reader :search_client
+
+  include Minitest::Hooks
+  include Helpers
+  @@search_config = Algolia::Search::Config.new(app_id: APPLICATION_ID_1, api_key: ADMIN_KEY_1, user_agent: USER_AGENT)
+  @@search_client = Algolia::Search::Client.new(@@search_config)
+end
+
+def check_environment_variables
+  raise Algolia::AlgoliaError, 'ALGOLIA_APPLICATION_ID_1 must be defined' if ENV['ALGOLIA_APPLICATION_ID_1'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_ADMIN_KEY_1 must be defined' if ENV['ALGOLIA_ADMIN_KEY_1'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_SEARCH_KEY_1 must be defined' if ENV['ALGOLIA_SEARCH_KEY_1'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_APPLICATION_ID_2 must be defined' if ENV['ALGOLIA_APPLICATION_ID_2'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_ADMIN_KEY_2 must be defined' if ENV['ALGOLIA_ADMIN_KEY_2'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_APPLICATION_ID_MCM must be defined' if ENV['ALGOLIA_APPLICATION_ID_MCM'].to_s.strip.empty?
+  raise Algolia::AlgoliaError, 'ALGOLIA_ADMIN_KEY_MCM must be defined' if ENV['ALGOLIA_ADMIN_KEY_MCM'].to_s.strip.empty?
+end
+
+def get_test_index_name(name)
+  date = DateTime.now.strftime('%Y-%m-%d_%H_%M_%S')
+  user = ENV['USER'] || 'unknown'
+
+  instance = ENV['CI'].to_s == 'true' ? ENV['CIRCLE_BUILD_NUM'] : user
+
+  format('ruby_%<date>s_%<instance>s_%<name>s', date: date, instance: instance, name: name)
+end
+
+def get_mcm_user_name(user_id)
+  date = DateTime.now.strftime('%Y-%m-%d')
+  user = ENV['USER'] || 'unknown'
+
+  instance = ENV['CI'].to_s == 'true' ? ENV['CIRCLE_BUILD_NUM'] : user
+
+  format('ruby-%<date>s-%<instance>s-%<user_id>s', date: date, instance: instance, user_id: user_id)
+end
+
+def generate_object(object_id = nil)
+  object = { property: 'property' }
+  if object_id
+    object[:objectID] = object_id
+  end
+
+  object
+end
+
+def create_employee_records
+  [
+    { company: 'Algolia', name: 'Julien Lemoine', objectID: 'julien-lemoine' },
+    { company: 'Algolia', name: 'Nicolas Dessaigne', objectID: 'nicolas-dessaigne' },
+    { company: 'Amazon', name: 'Jeff Bezos' },
+    { company: 'Apple', name: 'Steve Jobs' },
+    { company: 'Apple', name: 'Steve Wozniak' },
+    { company: 'Arista Networks', name: 'Jayshree Ullal' },
+    { company: 'Google', name: 'Larry Page' },
+    { company: 'Google', name: 'Rob Pike' },
+    { company: 'Google', name: 'Serguey Brin' },
+    { company: 'Microsoft', name: 'Bill Gates' },
+    { company: 'SpaceX', name: 'Elon Musk' },
+    { company: 'Tesla', name: 'Elon Musk' },
+    { company: 'Yahoo', name: 'Marissa Mayer' }
+  ]
+end
+
+def rule_without_metadata(rule)
+  rule.delete(:_metadata)
+  rule
+end

data/upgrade_guide.md

@@ -0,0 +1,595 @@
+# Upgrading to v2 of the Ruby API client
+
+## Gem
+First, you'll have to include the new version in your Gemfile. To do so, change the following:
+
+```diff
+- gem 'algoliasearch'
++ gem 'algolia', git: 'https://github.com/algolia/algoliasearch-client-ruby.git', tag: 'v2.0.0-alpha.1'
+```
+
+Then, you'll need to change your current `require` statements:
+
+```diff
+- require 'algoliasearch'
++ require 'algolia'
+```
+
+## Class names
+All classes have been namespaced. The mostly used classes are now as follows:
+ 
+- `Algolia::Client` -> `Algolia::Search::Client`
+- `Algolia::Index` -> `Algolia::Search::Index`
+- `Algolia::AccountClient` -> `Algolia::Account::Client`
+- `Algolia::Analytics` -> `Algolia::Analytics::Client`
+- `Algolia::Insights` -> `Algolia::Insights::Client`
+
+## Initialize the client and index
+There's a slight change in how you initialize the client. The index initialization didn't change.
+```ruby
+# Before
+client = Algolia::Client.new(
+   application_id: 'APP_ID',
+   api_key: 'API_KEY'
+)
+index = client.init_index('index_name')
+
+# After
+client = Algolia::Search::Client.create('APP_ID', 'API_KEY')
+index = client.init_index('index_name')
+# or
+search_config = Algolia::Search::Config.new(app_id: app_id, api_key: api_key)
+client = Algolia::Search::Client.create_with_config(search_config)
+index = client.init_index('index_name')
+```
+
+## Search parameters and request options
+The search parameters and request options are still optional, but they are combined into a single hash instead of two. 
+For example:
+```ruby
+# Before
+request_opts = { 'X-Algolia-UserToken': 'user123' }
+search_params = { hitsPerPage: 50 }
+
+index.search('query', search_params, request_opts)
+
+# After
+opts = {
+  :headers => {
+    'X-Algolia-UserToken': 'user123'
+  },
+  :params => {
+    hitsPerPage: 50
+  }
+}
+index.search('query', opts)
+```
+
+## Methods
+
+### `Client`
+
+#### `multiple_queries`
+The `strategy` parameter is no longer a string, but a key in the `requestOptions`.
+```ruby
+queries = [
+  { indexName: 'index_name1', params: { query: 'query', hitsPerPage: 2 } },
+  { indexName: 'index_name2', params: { query: 'another_query', hitsPerPage: 5 } }
+]
+
+# Before
+client.multiple_queries(queries, 'stopIfEnoughMatches')
+
+# After
+client.multiple_queries(queries, { strategy: 'stopIfEnoughMatches' })
+```
+
+#### `copy_settings`
+No change.
+
+#### `list_indexes`
+No change.
+
+#### `copy_index`
+No change.
+
+#### `move_index`
+No change.
+
+#### `generate_secured_api_key`
+This method is moved to the `Algolia::Search::Client` class.
+```ruby
+# Before
+secured_api_key = Algolia.generate_secured_api_key('api_key', {
+  validUntil: now - (10 * 60)
+})
+
+# After
+secured_api_key = Algolia::Search::Client.generate_secured_api_key('api_key', {
+  validUntil: now - (10 * 60)
+})
+```
+
+#### `add_api_key`
+`acl` is still the first parameter. The other parameters have been moved to the `requestOptions`.
+
+```ruby
+# Before
+client.add_api_key({ acl: ['search'], description: 'A description', indexes: ['index']})
+
+# After
+client.add_api_key(['search'], {
+  description: 'A description',
+  indexes: ['index']
+})
+```
+
+#### `update_api_key`
+This method is moved to the `Algolia::Search::Client` class.
+```ruby
+# Before
+Algolia.update_api_key('api_key', { maxHitsPerQuery: 42 })
+
+# After
+client.update_api_key('api_key', { maxHitsPerQuery: 42 })
+```
+
+#### `delete_api_key`
+No change.
+
+#### `restore_api_key`
+No change.
+
+#### `get_api_key`
+No change.
+
+#### `list_api_keys`
+No change.
+
+#### `get_secured_api_key_remaining_validity`
+This method is moved to the `Algolia::Search::Client` class.
+```ruby
+# Before
+Algolia.get_secured_api_key_remaining_validity('api_key')
+
+# After
+Algolia::Search::Client.get_secured_api_key_remaining_validity('api_key')
+```
+
+#### `copy_synonyms`
+No change.
+
+#### `assign_user_id`
+No change.
+
+#### `assign_user_ids`
+Newly added method to add multiple userIDs to a cluster.
+```ruby
+user_ids = ['1','2','3']
+
+# Before
+user_ids.each { |id| client.assign_user_id(id, 'my-cluster')}
+
+# After
+client.assign_user_ids(user_ids, 'my-cluster')
+```
+
+#### `get_top_user_id`
+No change.
+
+#### `get_user_id`
+No change.
+
+#### `list_clusters`
+No change.
+
+#### `list_user_ids`
+The `page` and `hitsPerPage` parameters are now part of the `requestOptions`.
+```ruby
+# Before
+page = 0
+hits_per_page = 20
+client.list_user_ids(page, hits_per_page)
+
+# After
+client.list_user_ids({ hitPerPage: 20, page: 0 })
+```
+
+#### `remove_user_id`
+No change.
+
+#### `search_user_ids`
+The `clusterName`, `page` and `hitsPerPage` parameters are now part of the `requestOptions`.
+```ruby
+# Before
+page = 0
+hits_per_page = 12
+client.search_user_ids('query', 'my-cluster', page, hits_per_page)
+
+# After
+client.search_user_ids('query', {clusterName: 'my-cluster', hitPerPage: 12, page: 0 })
+```
+
+#### `pending_mappings`
+New method to check the status of your clusters' migration or user creation.
+```ruby
+client.pending_mapping?({ retrieveMappings: true })
+``` 
+
+#### `get_logs`
+The `offset`, `length`, and `type` parameters are now part of the `requestOptions`.
+```ruby
+# Before
+offset = 5
+length = 100
+puts client.get_logs(offset, length, 'all')
+
+# After
+client.get_logs({ offset: 5, length: 10, type: 'all' })
+```
+
+#### `copy_rules`
+No change.
+
+### `Index`
+#### `search` 
+`searchParameters` and `requestOptions` are a single parameter now. 
+
+```ruby
+# Before
+request_opts = { 'X-Algolia-UserToken': 'user123' }
+search_params = { hitsPerPage: 50 }
+
+index.search('query', search_params, request_opts)
+
+# After
+opts = {
+  :headers => {
+    'X-Algolia-UserToken': 'user123'
+  },
+  :params => {
+    hitsPerPage: 50
+  }
+}
+index.search('query', opts)
+```
+
+#### `search_for_facet_values`
+`searchParameters` and `requestOptions` are a single parameter now.
+```ruby
+# Before
+request_opts = { 'X-Algolia-UserToken': 'user123' }
+search_params = { hitsPerPage: 50 }
+
+index.search_for_facet_values('category', 'phone', search_params, request_opts)
+
+# After
+opts = {
+  :headers => {
+    'X-Algolia-UserToken': 'user123'
+  },
+  :params => {
+    hitsPerPage: 50
+  }
+}
+index.search_for_facet_values('category', 'phone', opts)
+```
+
+#### `find_object`
+The method takes a lambda, proc or block as the first argument (anything that responds to `call`), and the `requestOptions` as the second
+```ruby
+# Before
+index.find_object({query: 'query', paginate: true}) { |hit| hit[:title].include?('algolia') }
+
+# After
+index.find_object(-> (hit) { hit[:title].include?('algolia') }, { query: 'query', paginate: true })
+```
+
+#### `get_object_position`
+The classname has changed, not the method itself.
+```ruby
+# Before
+position = Algolia::Index.get_object_position(results, 'object')
+
+# After
+position = Algolia::Search::Index.get_object_position(results, 'object')
+```
+
+#### `add_object` and `add_objects`
+These methods have been removed in favor of `save_object` and `save_objects`.
+
+#### `save_object` and `save_objects`
+No change.
+
+#### `partial_update_object`
+The `objectID` parameter is removed. `create_if_not_exists` is now part of the `requestOptions` parameter.
+
+```ruby
+obj = { objectID: '1234', prop: 'value' }
+
+# Before
+create_if_not_exists = true
+index.partial_update_object(obj, obj[:objectID], create_if_not_exists)
+
+# After
+index.partial_update_object(obj, { createIfNotExists: true })
+```
+
+#### `partial_update_objects`
+The `create_if_not_exists` parameter is now part of the `requestOptions` parameter.
+
+```ruby
+# Before
+create_if_not_exists = true
+index.partial_update_objects(objects, create_if_not_exists)
+
+# After
+index.partial_update_objects(objects, { createIfNotExists: true })
+```
+
+#### `delete_object` and `delete_objects`
+No change.
+
+#### `replace_all_objects`
+No change.
+
+#### `delete_by`
+No change.
+
+#### `clear_index`
+Renamed to `clear_objects`.
+```ruby
+# Before
+index.clear_index
+
+# After
+index.clear_objects
+```
+
+#### `get_object` and `get_objects`
+The `attributesToRetrieve` parameter is now part of the `requestOptions`.
+```ruby
+# Before
+index.get_object('1234', ['title'])
+index.get_objects([1,2,3], ['title'])
+
+# After 
+index.get_object('1234', { attributesToRetrieve: ['title'] })
+index.get_objects([1,2,3], { attributesToRetrieve: ['title'] })
+```
+
+#### `multiple_get_objects`
+No change.
+
+#### `batch`
+No change.
+
+#### `get_settings`
+No change.
+
+#### `set_settings`
+No change.
+
+#### `delete_index`
+Instead of calling the `delete_index` method on the client, you should call the `delete` method directly on the index object.
+
+```ruby
+# Before
+client.delete_index('foo')
+
+# After
+index.delete
+```
+
+#### `browse`
+Renamed to `browse_objects`.
+```ruby
+# Before
+request_opts = { 'X-Algolia-UserToken': 'user123' }
+index.browse({ query: 'query'}, nil, request_opts) do |hit|
+  puts hit
+end
+
+# After
+opts = {
+  query: 'query',
+  headers: { 'X-Algolia-UserToken': 'user123' }
+}
+index.browse_objects(opts) do |hit|
+  puts hit
+end
+```
+
+#### `index.exists?`
+No change.
+
+#### `save_synonym`
+The `objectID` parameter has been removed, and should be part of the synonym hash.
+```ruby
+# Before
+forward_to_replicas = true
+index.save_synonym('one', { objectID: 'one', type: 'synonym', synonyms: %w(one two) }, forward_to_replicas)
+
+# After
+index.save_synonym({ objectID: 'one', type: 'synonym', synonyms: %w(one two) }, { forwardToReplicas: true})
+```
+
+#### `batch_synonyms`
+Renamed to `save_synonyms`. `forwardToReplicas` and `replaceExistingSynonyms` parmameters are now part of `requestOptions`.
+```ruby
+# Before
+forward_to_replicas = true
+replace_existing_synonyms = true
+index.batch_synonyms(synonyms, forward_to_replicas, replace_existing_synonyms)
+# After
+index.save_synonyms(synonyms, { forwardToReplicas: true, replaceExistingSynonyms: true })
+```
+
+#### `delete_synonym`
+No change.
+
+#### `clear_synonyms`
+No change.
+
+#### `get_synonym`
+No change.
+
+#### `search_synonyms`
+No change.
+
+#### `replace_all_synonyms`
+No change.
+
+#### `export_synonyms`
+Renamed to `browse_synonyms`.
+```ruby
+# Before
+synonyms = index.export_synonyms
+
+# After
+synonyms = index.browse_synonyms
+```
+
+#### `save_rule`
+The `objectID` parameter has been removed, and should be part of the Rule object.
+```ruby
+# Before
+index.save_rule('unique-id', {
+  objectID: 'unique-id',
+  condition: { anchoring: 'is', pattern: 'pattern' },
+  consequence: {
+   params: {
+      query: {
+        edits: [
+          { type: 'remove', delete: 'pattern' }
+        ]
+      }
+    }
+  }
+})
+
+# After
+index.save_rule({
+  objectID: 'unique-id',
+  condition: { anchoring: 'is', pattern: 'pattern' },
+  consequence: {
+   params: {
+      query: {
+        edits: [
+          { type: 'remove', delete: 'pattern' }
+        ]
+      }
+    }
+  }
+})
+```
+
+#### `batch_rules`
+Renamed to `save_rules`. The `forwardToReplicas` and `clearExistingRules` parameters should now be part of the `requestOptions`.
+```ruby
+# Before
+forward_to_replicas = true
+clear_existing_rules = true
+index.batch_rules(rules, forward_to_replicas, clear_existing_rules)
+
+# After
+index.save_rules(rules, { forwardToReplicas: true, clearExistingRules: true })
+```
+
+#### `get_rule`
+No change.
+
+#### `delete_rule`
+The `forwardToReplicas` parameter is now part of the `requestOptions`.
+```ruby
+# Before
+forward_to_replicas = true
+index.delete_rule('rule-id', forward_to_replicas)
+
+# After
+index.delete_rule('rule-id', { forwardToReplicas: true })
+```
+
+#### `clear_rules`
+The `forwardToReplicas` parameter is now part of the `requestOptions`.
+```ruby
+# Before
+forward_to_replicas = true
+index.clear_rules(forward_to_replicas)
+
+# After
+index.clear_rules({ forwardToReplicas: true })
+```
+
+#### `search_rules`
+No change.
+
+#### `replace_all_rules`
+No change.
+
+#### `export_rules`
+Renamed to `browse_rules`.
+
+### `AnalyticsClient`
+#### `add_ab_test`
+No change.
+
+#### `get_ab_test`
+No change.
+
+#### `get_ab_tests`
+No change.
+
+#### `stop_ab_test`
+No change.
+
+#### `delete_ab_test`
+No change.
+
+### `InsightsClient`
+#### `clicked_object_ids_after_search`
+No change.
+
+#### `clicked_object_ids`
+No change.
+
+#### `clicked_filters`
+No change.
+
+#### `converted_object_ids_after_search`
+No change.
+
+#### `converted_object_ids`
+No change.
+
+#### `converted_filters`
+No change.
+
+#### `viewed_object_ids`
+No change.
+
+#### `viewed_filters`
+No change.
+
+### `RecommendationClient`
+#### `set_personalization_strategy`
+This new method is available on the `Algolia::Recommendation::Client` class.
+
+#### `set_personalization_strategy`
+This new method is available on the `Algolia::Recommendation::Client` class.
+
+## Configuring timeouts
+You can configure timeouts by passing a custom `Algolia::Search::Config` object to the constructor of your client.
+```ruby
+# Before
+client = Algolia::Client.new({
+  application_id: 'app_id',
+  api_key: 'api_key',
+  connect_timeout: 2,
+  receive_timeout: 10,
+})
+
+# After
+search_config = Algolia::Search::Config.new(app_id: 'app_id', api_key: 'api_key', read_timeout: 10, connect_timeout: 2)
+client = Algolia::Search::Client.create_with_config(search_config)
+```