meilisearch-rails 0.7.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: affe6d35bf6c1c626570b32ae605e3b1e826c16c86e87d9ea4cc2e67cb4c1512
-  data.tar.gz: b950799c5e8296d5fcbc2e194480cbbc4fa5a60b704708db55859f7d0a6d8e4c
+  metadata.gz: cd9b1257d27f252b6dc5caf4dcc3316d6b8e2a026b6266e4aec67eb05106ace0
+  data.tar.gz: 356acde3b6a894b8a3e8c2e2206c04527b5927968a33030a6f73e0d807f709af
 SHA512:
-  metadata.gz: 7a84a8fbbb00122c28c90c5573f1e5a93a3012a89f516ea35df68eba294aea20b7e169906400ad27b17d281359a2d3fb5933eda1338aecb2941e206b21b00002
-  data.tar.gz: c735267b627ef2100fc0cdd52bffa8d323d634b865c5ef5ba870d3839f8e2a0d03244e5478a056a26295fbd827c6ecbbd40a2994df8805fa194925add4c8533a
+  metadata.gz: a813264676828158494dd04f5192ab902fd735e3ef0bbc17960b9a8f54fdc581139ec528cd87c0883be6bc96becdce8d455c0055d31b0464f9ba0d53cfbf0751
+  data.tar.gz: 0b5c4276212a365b038de5492a606be125902bac3bb9417a7cdf279c6e8bccdc146eb84b991b3c8e55928ee99c99510934da0cbbe958813709b6af6725fd7922

data/Gemfile

@@ -1,5 +1,7 @@
 source 'https://rubygems.org'
 
+# gem 'meilisearch', path: '../meilisearch-ruby'
+
 gemspec
 
 gem 'rubysl', '~> 2.0', platform: :rbx if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
@@ -29,6 +31,7 @@ group :test do
   gem 'jdbc-sqlite3', platform: :jruby
   gem 'rspec', '~> 3.0'
   gem 'simplecov', require: 'false'
+  gem 'threads'
 
   gem 'byebug'
   gem 'dotenv', '~> 2.7', '>= 2.7.6'

data/README.md

@@ -23,18 +23,20 @@
 
 **Meilisearch Rails** is the Meilisearch integration for Ruby on Rails developers.
 
-**Meilisearch** is an open-source search engine. [Discover what Meilisearch is!](https://github.com/meilisearch/meilisearch)
+**Meilisearch** is an open-source search engine. [Learn more about Meilisearch.](https://github.com/meilisearch/meilisearch)
 
 ## Table of Contents <!-- omit in toc -->
 
 - [📖 Documentation](#-documentation)
 - [🤖 Compatibility with Meilisearch](#-compatibility-with-meilisearch)
-- [🚀 Getting Started](#-getting-started)
+- [🚀 Getting started](#-getting-started)
 - [Compatibility](#-compatibility)
 - [⚙️ Settings](#️-settings)
 - [🔍 Custom search](#-custom-search)
 - [🪛 Options](#-options)
   - [Meilisearch configuration & environment](#meilisearch-configuration--environment)
+  - [Pagination with `kaminari` or `will_paginate`](#backend-pagination-with-kaminari-or-will_paginate-)
+  - [Pagination with `pagy`](#backend-pagination-with-pagy-)
   - [Index configuration](#index-configuration)
     - [Custom attribute definition](#custom-attribute-definition)
     - [Custom primary key](#custom-primary-key)
@@ -60,7 +62,7 @@ To learn more about Meilisearch, check out our [Documentation](https://docs.meil
 
 ## 🤖 Compatibility with Meilisearch
 
-This package only guarantees the compatibility with the [version v0.28.0 of Meilisearch](https://github.com/meilisearch/meilisearch/releases/tag/v0.28.0).
+This package only guarantees the compatibility with the [version v0.30.0 of Meilisearch](https://github.com/meilisearch/meilisearch/releases/tag/v0.30.0).
 
 ## 🔧 Installation <!-- omit in toc -->
 
@@ -91,7 +93,7 @@ docker run -it --rm -p 7700:7700 getmeili/meilisearch:latest meilisearch --maste
 
 NB: you can also download Meilisearch from **Homebrew** or **APT**.
 
-## 🚀 Getting Started
+## 🚀 Getting started
 
 #### Configuration <!-- omit in toc -->
 
@@ -99,7 +101,7 @@ Create a new file `config/initializers/meilisearch.rb` to setup your `MEILISEARC
 
 ```ruby
 MeiliSearch::Rails.configuration = {
-  meilisearch_host: 'YourMeilisearchHost', # example: http://localhost:7700
+  meilisearch_url: 'YourMeilisearchUrl', # example: http://localhost:7700
   meilisearch_api_key: 'YourMeilisearchAPIKey',
 }
 ```
@@ -138,46 +140,6 @@ hits.each do |hit|
 end
 ```
 
-#### Backend Pagination <!-- omit in toc -->
-
-This gem supports:
-- [kaminari](https://github.com/amatsuda/kaminari)
-- [pagy](https://github.com/ddnexus/pagy)
-- [will_paginate](https://github.com/mislav/will_paginate).
-
-Specify the `:pagination_backend` in the configuration file:
-
-```ruby
-MeiliSearch::Rails.configuration = {
-  meilisearch_host: 'YourMeilisearchHost',
-  meilisearch_api_key: 'YourMeilisearchAPIKey',
-  pagination_backend: :kaminari #:will_paginate
-}
-```
-
-Then, as soon as you use the `search` method, the returning results will be paginated:
-
-```ruby
-# controller
-@hits = Book.search('harry potter')
-
-# views
-<% @hits.each do |hit| %>
-  <%= hit.title %>
-  <%= hit.author %>
-<% end %>
-
-<%= paginate @hits %> # if using kaminari
-
-<%= will_paginate @hits %> # if using will_paginate
-```
-
-The **number of hits per page defaults to 20**, you can customize it by adding the `hits_per_page` parameter to your search:
-
-```ruby
-Book.search('harry potter', hits_per_page: 10)
-```
-
 #### Extra Configuration <!-- omit in toc -->
 
 Requests made to Meilisearch may timeout and retry. To adapt the behavior to
@@ -185,7 +147,7 @@ your needs, you can change the parameters during configuration:
 
 ```ruby
 MeiliSearch::Rails.configuration = {
-  meilisearch_host: 'YourMeilisearchHost',
+  meilisearch_url: 'YourMeilisearchUrl',
   meilisearch_api_key: 'YourMeilisearchAPIKey',
   timeout: 2,
   max_retries: 1,
@@ -223,6 +185,7 @@ class Book < ApplicationRecord
     attributes_to_highlight ['*']
     attributes_to_crop [:description]
     crop_length 10
+    pagination max_total_hits: 1000
   end
 end
 ```
@@ -254,6 +217,125 @@ Book.search('*', sort: ['title:asc'])
 
 ### Meilisearch configuration & environment
 
+### Backend Pagination with `kaminari` or `will_paginate` <!-- omit in toc -->
+
+This gem supports:
+- [kaminari](https://github.com/amatsuda/kaminari)
+- [will_paginate](https://github.com/mislav/will_paginate)
+
+Specify the `:pagination_backend` in the configuration file:
+
+```ruby
+MeiliSearch::Rails.configuration = {
+  meilisearch_url: 'YourMeilisearchUrl',
+  meilisearch_api_key: 'YourMeilisearchAPIKey',
+  pagination_backend: :kaminari # :will_paginate
+}
+```
+
+Then, as soon as you use the `search` method, the returning results will be paginated:
+
+```ruby
+# controller
+@hits = Book.search('harry potter')
+
+# views
+<% @hits.each do |hit| %>
+  <%= hit.title %>
+  <%= hit.author %>
+<% end %>
+
+<%= paginate @hits %> # if using kaminari
+
+<%= will_paginate @hits %> # if using will_paginate
+```
+
+The **number of hits per page defaults to 20**, you can customize it by adding the `hits_per_page` parameter to your search:
+
+```ruby
+Book.search('harry potter', hits_per_page: 10)
+```
+
+### Backend Pagination with `pagy` <!-- omit in toc -->
+
+This gem supports [pagy](https://github.com/ddnexus/pagy) to paginate your search results.
+
+To use `pagy` with your `meilisearch-rails` you need to:
+
+Add the `pagy` gem to your Gemfile.
+Create a new initializer `pagy.rb` with this:
+
+```rb
+# config/initializers/pagy.rb
+
+require 'pagy/extras/meilisearch'
+```
+
+Then in your model you must extend `Pagy::Meilisearch`:
+
+```rb
+class Book < ApplicationRecord
+  include MeiliSearch::Rails
+  extend Pagy::Meilisearch
+
+  meilisearch # ...
+end
+```
+
+And in your controller and view:
+
+```rb
+# controllers/books_controller.rb
+def search
+  hits = Book.pagy_search(params[:query])
+  @pagy, @hits = pagy_meilisearch(hits, items: 25)
+end
+
+
+# views/books/search.html.rb
+<%== pagy_nav(@pagy) %>
+```
+
+:warning: There is no need to set `pagination_backend` in the configuration block `MeiliSearch::Rails.configuration` for `pagy`.
+
+Check [`ddnexus/pagy`](https://ddnexus.github.io/pagy/extras/meilisearch) for more information.
+
+#### Deactivate Meilisearch in certain moments
+
+By default HTTP connections to the Meilisearch URL is always active, but sometimes you want to disable the HTTP requests in a particular moment or environment.<br>
+you have multiple ways to achieve this.
+
+By adding `active: false` in the configuration initializer:
+
+```ruby
+MeiliSearch::Rails.configuration = {
+  meilisearch_url: 'YourMeilisearchUrl',
+  meilisearch_api_key: 'YourMeilisearchAPIKey',
+  active: false
+}
+```
+
+Or you can disable programmatically:
+
+```ruby
+MeiliSearch::Rails.deactivate! # all the following HTTP calls will be dismissed.
+
+# or you can pass a block to it:
+
+MeiliSearch::Rails.deactivate! do
+  # every Meilisearch call here will be dismissed, no error will be raised.
+  # after the block, Meilisearch state will be active. 
+end
+```
+
+You can also activate if you deactivated earlier:
+
+```ruby
+MeiliSearch::Rails.activate!
+```
+
+:warning: These calls are persistent, so prefer to use the method with the block. This way, you will not forget to activate it afterward.
+
 #### Custom index_uid <!-- omit in toc -->
 
 By default, the **index_uid** will be the class name, e.g. `Book`. You can customize the index_uid by using the `index_uid:` option.
@@ -272,7 +354,7 @@ You can suffix the index UID with the current Rails environment by setting it gl
 
 ```ruby
 MeiliSearch::Rails.configuration = {
-  meilisearch_host: 'YourMeilisearchHost',
+  meilisearch_url: 'YourMeilisearchUrl',
   meilisearch_api_key: 'YourMeilisearchAPIKey',
   per_environment: true
 }

data/lib/meilisearch/rails/configuration.rb

@@ -11,9 +11,41 @@ module MeiliSearch
         @_config = configuration
       end
 
+      def deactivate!
+        semaphore.synchronize do
+          @_config.merge!(active: false)
+
+          return unless block_given?
+
+          yield
+
+          @_config.merge!(active: true)
+        end
+      end
+
+      def activate!
+        semaphore.synchronize do
+          @_config.merge!(active: true)
+        end
+      end
+
+      def active?
+        configuration.fetch(:active, true)
+      end
+
+      def black_hole
+        @black_hole ||= NullObject.instance
+      end
+
+      def semaphore
+        @semaphore ||= Mutex.new
+      end
+
       def client
+        return black_hole unless active?
+
         ::MeiliSearch::Client.new(
-          configuration[:meilisearch_host] || 'http://localhost:7700',
+          configuration[:meilisearch_url] || 'http://localhost:7700',
           configuration[:meilisearch_api_key],
           configuration.slice(:timeout, :max_retries)
                        .merge(client_agents: MeiliSearch::Rails.qualified_version)

data/lib/meilisearch/rails/errors.rb

@@ -7,7 +7,7 @@ module MeiliSearch
     class NotConfigured < StandardError
       def message
         'Please configure Meilisearch. Set MeiliSearch::Rails.configuration = ' \
-          "{meilisearch_host: 'YOUR_MEILISEARCH_HOST', meilisearch_api_key: 'YOUR_API_KEY'}"
+          "{meilisearch_url: 'YOUR_MEILISEARCH_URL', meilisearch_api_key: 'YOUR_API_KEY'}"
       end
     end
   end

data/lib/meilisearch/rails/null_object.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+
+module MeiliSearch
+  module Rails
+    class NullObject
+      include Singleton
+
+      def map
+        []
+      end
+
+      def nil?
+        true
+      end
+
+      def method_missing(_method, *_args, &_block)
+        self
+      end
+
+      def respond_to_missing?(_method_name, _include_private = false)
+        false
+      end
+    end
+  end
+end

data/lib/meilisearch/rails/pagination/kaminari.rb

@@ -17,30 +17,18 @@ module MeiliSearch
           end
         end
 
-        def limit(_num)
-          # noop
-          self
-        end
-
-        def offset(_num)
-          # noop
-          self
-        end
+        def self.create(results, total_hits, options = {})
+          offset = ((options[:page] - 1) * options[:per_page])
+          array = new results, limit: options[:per_page], offset: offset, total_count: total_hits
 
-        class << self
-          def create(results, total_hits, options = {})
-            offset = ((options[:page] - 1) * options[:per_page])
-            array = new results, limit: options[:per_page], offset: offset, total_count: total_hits
-
-            if array.empty? && !results.empty?
-              # since Kaminari 0.16.0, you need to pad the results with nil values so it matches the offset param
-              # otherwise you'll get an empty array: https://github.com/amatsuda/kaminari/commit/29fdcfa8865f2021f710adaedb41b7a7b081e34d
-              results = ([nil] * offset) + results
-              array = new results, offset: offset, limit: options[:per_page], total_count: total_hits
-            end
-
-            array
+          if array.empty? && !results.empty?
+            # since Kaminari 0.16.0, you need to pad the results with nil values so it matches the offset param
+            # otherwise you'll get an empty array: https://github.com/amatsuda/kaminari/commit/29fdcfa8865f2021f710adaedb41b7a7b081e34d
+            results = Array.new(offset) + results
+            array = new results, offset: offset, limit: options[:per_page], total_count: total_hits
           end
+
+          array
         end
       end
     end

data/lib/meilisearch/rails/pagination/will_paginate.rb

@@ -11,9 +11,7 @@ module MeiliSearch
       class WillPaginate
         def self.create(results, total_hits, options = {})
           ::WillPaginate::Collection.create(options[:page], options[:per_page], total_hits) do |pager|
-            start = (options[:page] - 1) * options[:per_page]
-            paginated_results = results[start, options[:per_page]]
-            pager.replace paginated_results
+            pager.replace results
           end
         end
       end

data/lib/meilisearch/rails/pagination.rb

@@ -5,15 +5,28 @@ module MeiliSearch
       autoload :Kaminari, 'meilisearch/rails/pagination/kaminari'
 
       def self.create(results, total_hits, options = {})
-        return results if MeiliSearch::Rails.configuration[:pagination_backend].nil?
+        pagination_backend = MeiliSearch::Rails.configuration[:pagination_backend]
 
-        begin
-          backend = MeiliSearch::Rails.configuration[:pagination_backend].to_s.classify
+        if pagination_backend.nil? || (is_pagy = pagination_backend.to_s == 'pagy')
+          log_pagy_error if is_pagy
 
-          ::MeiliSearch::Rails::Pagination.const_get(backend).create(results, total_hits, options)
-        rescue NameError
-          raise(BadConfiguration, 'Unknown pagination backend')
+          return results
         end
+
+        load_pagination!(pagination_backend, results, total_hits, options)
+      end
+
+      def self.log_pagy_error
+        (::Rails.logger || Logger.new($stdout))
+          .warning('[meilisearch-rails] Remove `pagination_backend: :pagy` from your initializer, `pagy` it is not required for `pagy`')
+      end
+
+      def self.load_pagination!(pagination_backend, results, total_hits, options)
+        ::MeiliSearch::Rails::Pagination
+          .const_get(pagination_backend.to_s.classify)
+          .create(results, total_hits, options)
+      rescue NameError
+        raise(BadConfiguration, 'Invalid `pagination_backend:` configuration, check your initializer.')
       end
     end
   end

data/lib/meilisearch/rails/utilities.rb

@@ -40,6 +40,31 @@ module MeiliSearch
             klass.ms_set_settings
           end
         end
+
+        def indexable?(record, options)
+          return false unless options[:if].blank? || constraint_passes?(record, options[:if])
+          return false unless options[:unless].blank? || !constraint_passes?(record, options[:unless])
+
+          true
+        end
+
+        private
+
+        def constraint_passes?(record, constraint)
+          case constraint
+          when Symbol
+            record.send(constraint)
+          when String
+            record.send(constraint.to_sym)
+          when Enumerable
+            # All constraints must pass
+            constraint.all? { |inner_constraint| constraint_passes?(record, inner_constraint) }
+          else
+            raise ArgumentError, "Unknown constraint type: #{constraint} (#{constraint.class})" unless constraint.respond_to?(:call)
+
+            constraint.call(record)
+          end
+        end
       end
     end
   end

data/lib/meilisearch/rails/version.rb

@@ -2,7 +2,7 @@
 
 module MeiliSearch
   module Rails
-    VERSION = '0.7.2'
+    VERSION = '0.8.0'
 
     def self.qualified_version
       "Meilisearch Rails (v#{VERSION})"

data/lib/meilisearch-rails.rb

@@ -1,5 +1,5 @@
 require 'meilisearch'
-
+require 'meilisearch/rails/null_object'
 require 'meilisearch/rails/version'
 require 'meilisearch/rails/utilities'
 require 'meilisearch/rails/errors'
@@ -59,8 +59,11 @@ module MeiliSearch
         attributesToHighlight
         attributesToCrop
         cropLength
+        pagination
       ].freeze
 
+      CAMELIZE_OPTIONS = %i[pagination].freeze
+
       OPTIONS.each do |option|
         define_method option do |value|
           instance_variable_set("@#{option}", value)
@@ -199,7 +202,13 @@ module MeiliSearch
         settings = {}
         OPTIONS.each do |k|
           v = get_setting(k)
-          settings[k] = v unless v.nil?
+          next if v.nil?
+
+          settings[k] = if CAMELIZE_OPTIONS.include?(k) && v.is_a?(Hash)
+                          v.transform_keys { |key| key.to_s.camelize(:lower) }
+                        else
+                          v
+                        end
         end
         settings
       end
@@ -249,7 +258,10 @@ module MeiliSearch
             args[0].delete(:attributesToCrop) if args[0][:attributesToCrop]
             args[0].delete(:cropLength) if args[0][:cropLength]
           end
+
           SafeIndex.log_or_throw(m, @raise_on_failure) do
+            return MeiliSearch::Rails.black_hole unless MeiliSearch::Rails.active?
+
             @index.send(m, *args, &block)
           end
         end
@@ -281,7 +293,7 @@ module MeiliSearch
         raise e if raise_on_failure
 
         # log the error
-        (::Rails.logger || Logger.new($stdout)).error("[meilisearch-rails] #{e.message}")
+        (::Rails.logger || Logger.new($stdout)).info("[meilisearch-rails] #{e.message}")
         # return something
         case method.to_s
         when 'search'
@@ -342,7 +354,7 @@ module MeiliSearch
           end
         end
         if options[:enqueue]
-          raise ArgumentError, 'Cannot use a enqueue if the `synchronous` option if set' if options[:synchronous]
+          raise ArgumentError, 'Cannot use a enqueue if the `synchronous` option is set' if options[:synchronous]
 
           proc = if options[:enqueue] == true
                    proc do |record, remove|
@@ -452,10 +464,10 @@ module MeiliSearch
           ms_find_in_batches(batch_size) do |group|
             if ms_conditional_index?(options)
               # delete non-indexable documents
-              ids = group.select { |d| !ms_indexable?(d, options) }.map { |d| ms_primary_key_of(d, options) }
+              ids = group.select { |d| !Utilities.indexable?(d, options) }.map { |d| ms_primary_key_of(d, options) }
               index.delete_documents(ids.select(&:present?))
               # select only indexable documents
-              group = group.select { |d| ms_indexable?(d, options) }
+              group = group.select { |d| Utilities.indexable?(d, options) }
             end
             documents = group.map do |d|
               attributes = settings.get_attributes(d)
@@ -502,7 +514,7 @@ module MeiliSearch
 
           primary_key = ms_primary_key_of(document, options)
           index = ms_ensure_init(options, settings)
-          if ms_indexable?(document, options)
+          if Utilities.indexable?(document, options)
             raise ArgumentError, 'Cannot index a record without a primary key' if primary_key.blank?
 
             doc = settings.get_attributes(document)
@@ -550,7 +562,7 @@ module MeiliSearch
 
           index = ms_ensure_init(options, settings)
           synchronous || options[:synchronous] ? index.delete_all_documents! : index.delete_all_documents
-          @ms_indexes[settings] = nil
+          @ms_indexes[MeiliSearch::Rails.active?][settings] = nil
         end
         nil
       end
@@ -599,18 +611,15 @@ module MeiliSearch
 
       def ms_search(query, params = {})
         if MeiliSearch::Rails.configuration[:pagination_backend]
-          page = params[:page].nil? ? params[:page] : params[:page].to_i
-          hits_per_page = params[:hitsPerPage].nil? ? params[:hitsPerPage] : params[:hitsPerPage].to_i
-          hits_per_page ||= params[:hits_per_page].nil? ? params[:hits_per_page] : params[:hits_per_page].to_i
-
-          %i[page hitsPerPage hits_per_page].each { |param| params.delete(param) }
+          %i[page hitsPerPage hits_per_page].each do |key|
+            params[key.to_s.underscore.to_sym] = params[key].to_i if params.key?(key)
+          end
 
-          params[:limit] = 200
+          # It is required to activate the finite pagination in Meilisearch v0.30 (or newer),
+          # to have at least `hits_per_page` defined or `page` in the search request.
+          params[:page] ||= 1
         end
 
-        # Returns raw json hits as follows:
-        # {"hits"=>[{"id"=>"13", "href"=>"apple", "name"=>"iphone"}], "offset"=>0, "limit"=>|| 20, "estimatedTotalHits"=>1,
-        #  "processingTimeMs"=>0, "query"=>"iphone"}
         json = ms_raw_search(query, params)
 
         # condition_key gets the primary key of the document; looks for "id" on the options
@@ -653,11 +662,7 @@ module MeiliSearch
           end
         end.compact
 
-        total_hits = json['hits'].length
-        hits_per_page ||= 20
-        page ||= 1
-
-        res = MeiliSearch::Rails::Pagination.create(results, total_hits, meilisearch_options.merge(page: page, per_page: hits_per_page))
+        res = Pagination.create(results, json['totalHits'], meilisearch_options.merge(page: json['page'], per_page: json['hitsPerPage']))
         res.extend(AdditionalMethods)
         res.send(:ms_init_raw_answer, json)
         res
@@ -720,16 +725,16 @@ module MeiliSearch
       def ms_ensure_init(options = nil, settings = nil, index_settings = nil)
         raise ArgumentError, 'No `meilisearch` block found in your model.' if meilisearch_settings.nil?
 
-        @ms_indexes ||= {}
+        @ms_indexes ||= { true => {}, false => {} }
 
         options ||= meilisearch_options
         settings ||= meilisearch_settings
 
-        return @ms_indexes[settings] if @ms_indexes[settings]
+        return @ms_indexes[MeiliSearch::Rails.active?][settings] if @ms_indexes[MeiliSearch::Rails.active?][settings]
 
-        @ms_indexes[settings] = SafeIndex.new(ms_index_uid(options), meilisearch_options[:raise_on_failure], meilisearch_options)
+        @ms_indexes[MeiliSearch::Rails.active?][settings] = SafeIndex.new(ms_index_uid(options), meilisearch_options[:raise_on_failure], meilisearch_options)
 
-        current_settings = @ms_indexes[settings].settings(getVersion: 1) rescue nil # if the index doesn't exist
+        current_settings = @ms_indexes[MeiliSearch::Rails.active?][settings].settings(getVersion: 1) rescue nil # if the index doesn't exist
 
         index_settings ||= settings.to_settings
         index_settings = options[:primary_settings].to_settings.merge(index_settings) if options[:inherit]
@@ -737,10 +742,10 @@ module MeiliSearch
         options[:check_settings] = true if options[:check_settings].nil?
 
         if !ms_indexing_disabled?(options) && options[:check_settings] && meilisearch_settings_changed?(current_settings, index_settings)
-          @ms_indexes[settings].update_settings(index_settings)
+          @ms_indexes[MeiliSearch::Rails.active?][settings].update_settings(index_settings)
         end
 
-        @ms_indexes[settings]
+        @ms_indexes[MeiliSearch::Rails.active?][settings]
       end
 
       private
@@ -802,31 +807,6 @@ module MeiliSearch
         options[:if].present? || options[:unless].present?
       end
 
-      def ms_indexable?(document, options = nil)
-        options ||= meilisearch_options
-        if_passes = options[:if].blank? || ms_constraint_passes?(document, options[:if])
-        unless_passes = options[:unless].blank? || !ms_constraint_passes?(document, options[:unless])
-        if_passes && unless_passes
-      end
-
-      def ms_constraint_passes?(document, constraint)
-        case constraint
-        when Symbol
-          document.send(constraint)
-        when String
-          document.send(constraint.to_sym)
-        when Enumerable
-          # All constraints must pass
-          constraint.all? { |inner_constraint| ms_constraint_passes?(document, inner_constraint) }
-        else
-          unless constraint.respond_to?(:call)
-            raise ArgumentError, "Unknown constraint type: #{constraint} (#{constraint.class})"
-          end
-
-          constraint.call(document)
-        end
-      end
-
       def ms_indexing_disabled?(options = nil)
         options ||= meilisearch_options
         constraint = options[:disable_indexing] || options['disable_indexing']
@@ -902,6 +882,8 @@ module MeiliSearch
       end
 
       def ms_enqueue_index!(synchronous)
+        return unless Utilities.indexable?(self, meilisearch_options)
+
         if meilisearch_options[:enqueue]
           unless self.class.send(:ms_indexing_disabled?, meilisearch_options)
             meilisearch_options[:enqueue].call(self, false)

data/meilisearch-rails.gemspec

@@ -34,5 +34,5 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 2.6.0'
 
-  s.add_dependency 'meilisearch', '~> 0.19.2'
+  s.add_dependency 'meilisearch', '~> 0.21.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meilisearch-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.8.0
 platform: ruby
 authors:
 - Meili
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-18 00:00:00.000000000 Z
+date: 2022-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meilisearch
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.21.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: 0.21.0
 description: Meilisearch integration for Ruby on Rails. See https://github.com/meilisearch/meilisearch
 email: bonjour@meilisearch.com
 executables: []
@@ -41,6 +41,7 @@ files:
 - lib/meilisearch/rails/configuration.rb
 - lib/meilisearch/rails/errors.rb
 - lib/meilisearch/rails/ms_job.rb
+- lib/meilisearch/rails/null_object.rb
 - lib/meilisearch/rails/pagination.rb
 - lib/meilisearch/rails/pagination/kaminari.rb
 - lib/meilisearch/rails/pagination/will_paginate.rb