meilisearch-rails 0.7.2 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: affe6d35bf6c1c626570b32ae605e3b1e826c16c86e87d9ea4cc2e67cb4c1512
-  data.tar.gz: b950799c5e8296d5fcbc2e194480cbbc4fa5a60b704708db55859f7d0a6d8e4c
+  metadata.gz: 849d3f11092d279468f2303406fac8ed52849490cd5f044d0f111c2731593f76
+  data.tar.gz: 41ec2f87a63e74bb6c4237435490b381f80def5dee0f8393c3a40cd583386a03
 SHA512:
-  metadata.gz: 7a84a8fbbb00122c28c90c5573f1e5a93a3012a89f516ea35df68eba294aea20b7e169906400ad27b17d281359a2d3fb5933eda1338aecb2941e206b21b00002
-  data.tar.gz: c735267b627ef2100fc0cdd52bffa8d323d634b865c5ef5ba870d3839f8e2a0d03244e5478a056a26295fbd827c6ecbbd40a2994df8805fa194925add4c8533a
+  metadata.gz: c6fb870cced8f9e395f5bbc23404331d932b8ebe92921f9867ce53e4b682a114d4a39a0d319a44395fe9d2e4f5907752ca923febee4503b4fa23df437f2237ab
+  data.tar.gz: d74ded33afca229deb79ed57ab820c0737f1bb2b3f258aafa4155a3d29515e24a0b9cb5680d106d0ebd9e39892f9a9e45aed8a50b934669558b8c9c11d1eddb5

data/Gemfile

@@ -29,6 +29,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

@@ -254,6 +254,42 @@ Book.search('*', sort: ['title:asc'])
 
 ### Meilisearch configuration & environment
 
+#### 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_host: 'YourMeilisearchHost',
+  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.

data/lib/meilisearch/rails/configuration.rb

@@ -11,7 +11,39 @@ 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_api_key],

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/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.7.3'
 
     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'
@@ -249,7 +249,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
@@ -342,7 +345,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 +455,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 +505,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 +553,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
@@ -720,16 +723,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 +740,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 +805,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 +880,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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: meilisearch-rails
 version: !ruby/object:Gem::Version
-  version: 0.7.2
+  version: 0.7.3
 platform: ruby
 authors:
 - Meili
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-18 00:00:00.000000000 Z
+date: 2022-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: meilisearch
@@ -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