searchkick 4.4.0 → 5.3.1

data/lib/searchkick/results.rb

@@ -1,10 +1,9 @@
-require "forwardable"
-
 module Searchkick
   class Results
     include Enumerable
     extend Forwardable
 
+    # TODO remove klass and options in 6.0
     attr_reader :klass, :response, :options
 
     def_delegators :results, :each, :any?, :empty?, :size, :length, :slice, :[], :to_ary
@@ -15,82 +14,23 @@ module Searchkick
       @options = options
     end
 
+    # TODO make private in 6.0
     def results
       @results ||= with_hit.map(&:first)
     end
 
     def with_hit
-      @with_hit ||= begin
-        if options[:load]
-          # results can have different types
-          results = {}
-
-          hits.group_by { |hit, _| hit["_index"] }.each do |index, grouped_hits|
-            klasses =
-              if @klass
-                [@klass]
-              else
-                index_alias = index.split("_")[0..-2].join("_")
-                Array((options[:index_mapping] || {})[index_alias])
-              end
-            raise Searchkick::Error, "Unknown model for index: #{index}" unless klasses.any?
-
-            results[index] = {}
-            klasses.each do |klass|
-              results[index].merge!(results_query(klass, grouped_hits).to_a.index_by { |r| r.id.to_s })
-            end
-          end
-
-          missing_ids = []
-
-          # sort
-          results =
-            hits.map do |hit|
-              result = results[hit["_index"]][hit["_id"].to_s]
-              if result && !(options[:load].is_a?(Hash) && options[:load][:dumpable])
-                if (hit["highlight"] || options[:highlight]) && !result.respond_to?(:search_highlights)
-                  highlights = hit_highlights(hit)
-                  result.define_singleton_method(:search_highlights) do
-                    highlights
-                  end
-                end
-              end
-              [result, hit]
-            end.select do |result, hit|
-              missing_ids << hit["_id"] unless result
-              result
-            end
-
-          if missing_ids.any?
-            Searchkick.warn("Records in search index do not exist in database: #{missing_ids.join(", ")}")
-          end
-
-          results
-        else
-          hits.map do |hit|
-            result =
-              if hit["_source"]
-                hit.except("_source").merge(hit["_source"])
-              elsif hit["fields"]
-                hit.except("fields").merge(hit["fields"])
-              else
-                hit
-              end
-
-            if hit["highlight"] || options[:highlight]
-              highlight = Hash[hit["highlight"].to_a.map { |k, v| [base_field(k), v.first] }]
-              options[:highlighted_fields].map { |k| base_field(k) }.each do |k|
-                result["highlighted_#{k}"] ||= (highlight[k] || result[k])
-              end
-            end
+      return enum_for(:with_hit) unless block_given?
 
-            result["id"] ||= result["_id"] # needed for legacy reasons
-            [HashWrapper.new(result), hit]
-          end
-        end
+      build_hits.each do |result|
+        yield result
       end
     end
 
+    def missing_records
+      @missing_records ||= with_hit_and_missing_records[1]
+    end
+
     def suggestions
       if response["suggest"]
         response["suggest"].values.flat_map { |v| v.first["options"] }.sort_by { |o| -o["score"] }.map { |o| o["text"] }.uniq
@@ -129,7 +69,11 @@ module Searchkick
     end
 
     def model_name
-      klass.model_name
+      if klass.nil?
+        ActiveModel::Name.new(self.class, nil, 'Result')
+      else
+        klass.model_name
+      end
     end
 
     def entry_name(options = {})
@@ -199,7 +143,7 @@ module Searchkick
 
     def hits
       if error
-        raise Searchkick::Error, "Query error - use the error method to view it"
+        raise Error, "Query error - use the error method to view it"
       else
         @response["hits"]["hits"]
       end
@@ -212,8 +156,18 @@ module Searchkick
     end
 
     def with_highlights(multiple: false)
-      with_hit.map do |result, hit|
-        [result, hit_highlights(hit, multiple: multiple)]
+      return enum_for(:with_highlights, multiple: multiple) unless block_given?
+
+      with_hit.each do |result, hit|
+        yield result, hit_highlights(hit, multiple: multiple)
+      end
+    end
+
+    def with_score
+      return enum_for(:with_score) unless block_given?
+
+      with_hit.each do |result, hit|
+        yield result, hit["_score"]
       end
     end
 
@@ -226,7 +180,7 @@ module Searchkick
     end
 
     def scroll
-      raise Searchkick::Error, "Pass `scroll` option to the search method for scrolling" unless scroll_id
+      raise Error, "Pass `scroll` option to the search method for scrolling" unless scroll_id
 
       if block_given?
         records = self
@@ -237,17 +191,12 @@ module Searchkick
 
         records.clear_scroll
       else
-        params = {
-          scroll: options[:scroll],
-          scroll_id: scroll_id
-        }
-
         begin
           # TODO Active Support notifications for this scroll call
-          Searchkick::Results.new(@klass, Searchkick.client.scroll(params), @options)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
-          if e.class.to_s =~ /NotFound/ && e.message =~ /search_context_missing_exception/i
-            raise Searchkick::Error, "Scroll id has expired"
+          Results.new(@klass, Searchkick.client.scroll(scroll: options[:scroll], body: {scroll_id: scroll_id}), @options)
+        rescue => e
+          if Searchkick.not_found_error?(e) && e.message =~ /search_context_missing_exception/i
+            raise Error, "Scroll id has expired"
           else
             raise e
           end
@@ -261,30 +210,116 @@ module Searchkick
         # not required as scroll will expire
         # but there is a cost to open scrolls
         Searchkick.client.clear_scroll(scroll_id: scroll_id)
-      rescue Elasticsearch::Transport::Transport::Error
-        # do nothing
+      rescue => e
+        raise e unless Searchkick.transport_error?(e)
       end
     end
 
     private
 
+    def with_hit_and_missing_records
+      @with_hit_and_missing_records ||= begin
+        missing_records = []
+
+        if options[:load]
+          grouped_hits = hits.group_by { |hit, _| hit["_index"] }
+
+          # determine models
+          index_models = {}
+          grouped_hits.each do |index, _|
+            models =
+              if @klass
+                [@klass]
+              else
+                index_alias = index.split("_")[0..-2].join("_")
+                Array((options[:index_mapping] || {})[index_alias])
+              end
+            raise Error, "Unknown model for index: #{index}. Pass the `models` option to the search method." unless models.any?
+            index_models[index] = models
+          end
+
+          # fetch results
+          results = {}
+          grouped_hits.each do |index, index_hits|
+            results[index] = {}
+            index_models[index].each do |model|
+              results[index].merge!(results_query(model, index_hits).to_a.index_by { |r| r.id.to_s })
+            end
+          end
+
+          # sort
+          results =
+            hits.map do |hit|
+              result = results[hit["_index"]][hit["_id"].to_s]
+              if result && !(options[:load].is_a?(Hash) && options[:load][:dumpable])
+                if (hit["highlight"] || options[:highlight]) && !result.respond_to?(:search_highlights)
+                  highlights = hit_highlights(hit)
+                  result.define_singleton_method(:search_highlights) do
+                    highlights
+                  end
+                end
+              end
+              [result, hit]
+            end.select do |result, hit|
+              unless result
+                models = index_models[hit["_index"]]
+                missing_records << {
+                  id: hit["_id"],
+                  # may be multiple models for inheritance with child models
+                  # not ideal to return different types
+                  # but this situation shouldn't be common
+                  model: models.size == 1 ? models.first : models
+                }
+              end
+              result
+            end
+        else
+          results =
+            hits.map do |hit|
+              result =
+                if hit["_source"]
+                  hit.except("_source").merge(hit["_source"])
+                elsif hit["fields"]
+                  hit.except("fields").merge(hit["fields"])
+                else
+                  hit
+                end
+
+              if hit["highlight"] || options[:highlight]
+                highlight = hit["highlight"].to_a.to_h { |k, v| [base_field(k), v.first] }
+                options[:highlighted_fields].map { |k| base_field(k) }.each do |k|
+                  result["highlighted_#{k}"] ||= (highlight[k] || result[k])
+                end
+              end
+
+              result["id"] ||= result["_id"] # needed for legacy reasons
+              [HashWrapper.new(result), hit]
+            end
+        end
+
+       [results, missing_records]
+      end
+    end
+
+    def build_hits
+      @build_hits ||= begin
+        if missing_records.any?
+          Searchkick.warn("Records in search index do not exist in database: #{missing_records.map { |v| "#{Array(v[:model]).map(&:model_name).sort.join("/")} #{v[:id]}" }.join(", ")}")
+        end
+        with_hit_and_missing_records[0]
+      end
+    end
+
     def results_query(records, hits)
+      records = Searchkick.scope(records)
+
       ids = hits.map { |hit| hit["_id"] }
       if options[:includes] || options[:model_includes]
         included_relations = []
         combine_includes(included_relations, options[:includes])
         combine_includes(included_relations, options[:model_includes][records]) if options[:model_includes]
 
-        records =
-          if defined?(NoBrainer::Document) && records < NoBrainer::Document
-            if Gem.loaded_specs["nobrainer"].version >= Gem::Version.new("0.21")
-              records.eager_load(included_relations)
-            else
-              records.preload(included_relations)
-            end
-          else
-            records.includes(included_relations)
-          end
+        records = records.includes(included_relations)
       end
 
       if options[:scope_results]
@@ -310,7 +345,7 @@ module Searchkick
 
     def hit_highlights(hit, multiple: false)
       if hit["highlight"]
-        Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }]
+        hit["highlight"].to_h { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }
       else
         {}
       end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "4.4.0"
+  VERSION = "5.3.1"
 end

data/lib/searchkick/where.rb

@@ -0,0 +1,11 @@
+module Searchkick
+  class Where
+    def initialize(relation)
+      @relation = relation
+    end
+
+    def not(value)
+      @relation.where(_not: value)
+    end
+  end
+end