tiny-quick-gem 0.0.1

data/searchkick-6.1.2/lib/searchkick/relation_indexer.rb

@@ -0,0 +1,184 @@
+module Searchkick
+  class RelationIndexer
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+
+    def reindex(relation, mode:, method_name: nil, ignore_missing: nil, full: false, resume: false, scope: nil, job_options: nil)
+      # apply scopes
+      if scope
+        relation = relation.send(scope)
+      elsif relation.respond_to?(:search_import)
+        relation = relation.search_import
+      end
+
+      # remove unneeded loading for async and queue
+      if mode == :async || mode == :queue
+        if relation.respond_to?(:primary_key)
+          relation = relation.except(:includes, :preload)
+          unless mode == :queue && relation.klass.method_defined?(:search_routing)
+            relation = relation.except(:select).select(relation.primary_key)
+          end
+        elsif relation.respond_to?(:only)
+          unless mode == :queue && relation.klass.method_defined?(:search_routing)
+            relation = relation.only(:_id)
+          end
+        end
+      end
+
+      if mode == :async && full
+        return full_reindex_async(relation, job_options: job_options)
+      end
+
+      relation = resume_relation(relation) if resume
+
+      reindex_options = {
+        mode: mode,
+        method_name: method_name,
+        full: full,
+        ignore_missing: ignore_missing,
+        job_options: job_options
+      }
+      record_indexer = RecordIndexer.new(index)
+
+      in_batches(relation) do |items|
+        record_indexer.reindex(items, **reindex_options)
+      end
+    end
+
+    def batches_left
+      Searchkick.with_redis { |r| r.call("SCARD", batches_key) }
+    end
+
+    def batch_completed(batch_id)
+      Searchkick.with_redis { |r| r.call("SREM", batches_key, [batch_id]) }
+    end
+
+    private
+
+    def resume_relation(relation)
+      if relation.respond_to?(:primary_key)
+        # use total docs instead of max id since there's not a great way
+        # to get the max _id without scripting since it's a string
+        where = relation.arel_table[relation.primary_key].gt(index.total_docs)
+        relation = relation.where(where)
+      else
+        raise Error, "Resume not supported for Mongoid"
+      end
+    end
+
+    def in_batches(relation)
+      if relation.respond_to?(:find_in_batches)
+        klass = relation.klass
+        # remove order to prevent possible warnings
+        relation.except(:order).find_in_batches(batch_size: batch_size) do |batch|
+          # prevent scope from affecting search_data as well as inline jobs
+          # Active Record runs relation calls in scoping block
+          # https://github.com/rails/rails/blob/main/activerecord/lib/active_record/relation/delegation.rb
+          # note: we could probably just call klass.current_scope = nil
+          # anywhere in reindex method (after initial all call),
+          # but this is more cautious
+          previous_scope = klass.current_scope(true)
+          if previous_scope
+            begin
+              klass.current_scope = nil
+              yield batch
+            ensure
+              klass.current_scope = previous_scope
+            end
+          else
+            yield batch
+          end
+        end
+      else
+        klass = relation.klass
+        each_batch(relation, batch_size: batch_size) do |batch|
+          # prevent scope from affecting search_data as well as inline jobs
+          # note: Model.with_scope doesn't always restore scope, so use custom logic
+          previous_scope = Mongoid::Threaded.current_scope(klass)
+          if previous_scope
+            begin
+              Mongoid::Threaded.set_current_scope(nil, klass)
+              yield batch
+            ensure
+              Mongoid::Threaded.set_current_scope(previous_scope, klass)
+            end
+          else
+            yield batch
+          end
+        end
+      end
+    end
+
+    def each_batch(relation, batch_size:)
+      # https://github.com/karmi/tire/blob/master/lib/tire/model/import.rb
+      # use cursor for Mongoid
+      items = []
+      relation.all.each do |item|
+        items << item
+        if items.length == batch_size
+          yield items
+          items = []
+        end
+      end
+      yield items if items.any?
+    end
+
+    def batch_size
+      @batch_size ||= index.options[:batch_size] || 1000
+    end
+
+    def full_reindex_async(relation, job_options: nil)
+      batch_id = 1
+      class_name = relation.searchkick_options[:class_name]
+      starting_id = false
+
+      if relation.respond_to?(:primary_key)
+        primary_key = relation.primary_key
+
+        starting_id =
+          begin
+            relation.minimum(primary_key)
+          rescue ActiveRecord::StatementInvalid
+            false
+          end
+      end
+
+      if starting_id.nil?
+        # no records, do nothing
+      elsif starting_id.is_a?(Numeric)
+        max_id = relation.maximum(primary_key)
+        batches_count = ((max_id - starting_id + 1) / batch_size.to_f).ceil
+
+        batches_count.times do |i|
+          min_id = starting_id + (i * batch_size)
+          batch_job(class_name, batch_id, job_options, min_id: min_id, max_id: min_id + batch_size - 1)
+          batch_id += 1
+        end
+      else
+        in_batches(relation) do |items|
+          batch_job(class_name, batch_id, job_options, record_ids: items.map(&:id).map { |v| v.instance_of?(Integer) ? v : v.to_s })
+          batch_id += 1
+        end
+      end
+    end
+
+    def batch_job(class_name, batch_id, job_options, **options)
+      job_options ||= {}
+      # TODO expire Redis key
+      Searchkick.with_redis { |r| r.call("SADD", batches_key, [batch_id]) }
+      Searchkick::BulkReindexJob.set(**job_options).perform_later(
+        class_name: class_name,
+        index_name: index.name,
+        batch_id: batch_id,
+        **options
+      )
+    end
+
+    def batches_key
+      "searchkick:reindex:#{index.name}:batches"
+    end
+  end
+end

data/searchkick-6.1.2/lib/searchkick/reranking.rb

@@ -0,0 +1,28 @@
+module Searchkick
+  module Reranking
+    def self.rrf(first_ranking, *rankings, k: 60)
+      rankings.unshift(first_ranking)
+      rankings.map!(&:to_ary)
+
+      ranks = []
+      results = []
+      rankings.each do |ranking|
+        ranks << ranking.map.with_index.to_h { |v, i| [v, i + 1] }
+        results.concat(ranking)
+      end
+
+      results =
+        results.uniq.map do |result|
+          score =
+            ranks.sum do |rank|
+              r = rank[result]
+              r ? 1.0 / (k + r) : 0.0
+            end
+
+          {result: result, score: score}
+        end
+
+      results.sort_by { |v| -v[:score] }
+    end
+  end
+end

data/searchkick-6.1.2/lib/searchkick/results.rb

@@ -0,0 +1,359 @@
+module Searchkick
+  class Results
+    include Enumerable
+    extend Forwardable
+
+    attr_reader :response
+
+    def_delegators :results, :each, :any?, :empty?, :size, :length, :slice, :[], :to_ary
+
+    def initialize(klass, response, options = {})
+      @klass = klass
+      @response = response
+      @options = options
+    end
+
+    def with_hit
+      return enum_for(:with_hit) unless block_given?
+
+      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
+      elsif options[:suggest]
+        []
+      else
+        raise "Pass `suggest: true` to the search method for suggestions"
+      end
+    end
+
+    def aggregations
+      response["aggregations"]
+    end
+
+    def aggs
+      @aggs ||= begin
+        if aggregations
+          aggregations.dup.each do |field, filtered_agg|
+            buckets = filtered_agg[field]
+            # move the buckets one level above into the field hash
+            if buckets
+              filtered_agg.delete(field)
+              filtered_agg.merge!(buckets)
+            end
+          end
+        end
+      end
+    end
+
+    def took
+      response["took"]
+    end
+
+    def error
+      response["error"]
+    end
+
+    def model_name
+      if klass.nil?
+        ActiveModel::Name.new(self.class, nil, 'Result')
+      else
+        klass.model_name
+      end
+    end
+
+    def entry_name(options = {})
+      if options.empty?
+        # backward compatibility
+        model_name.human.downcase
+      else
+        default = options[:count] == 1 ? model_name.human : model_name.human.pluralize
+        model_name.human(options.reverse_merge(default: default))
+      end
+    end
+
+    def total_count
+      if options[:total_entries]
+        options[:total_entries]
+      elsif response["hits"]["total"].is_a?(Hash)
+        response["hits"]["total"]["value"]
+      else
+        response["hits"]["total"]
+      end
+    end
+    alias_method :total_entries, :total_count
+
+    def current_page
+      options[:page]
+    end
+
+    def per_page
+      options[:per_page]
+    end
+    alias_method :limit_value, :per_page
+
+    def padding
+      options[:padding]
+    end
+
+    def total_pages
+      (total_count / per_page.to_f).ceil
+    end
+    alias_method :num_pages, :total_pages
+
+    def offset_value
+      (current_page - 1) * per_page + padding
+    end
+    alias_method :offset, :offset_value
+
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+    alias_method :prev_page, :previous_page
+
+    def next_page
+      current_page < total_pages ? (current_page + 1) : nil
+    end
+
+    def first_page?
+      previous_page.nil?
+    end
+
+    def last_page?
+      next_page.nil?
+    end
+
+    def out_of_range?
+      current_page > total_pages
+    end
+
+    def hits
+      if error
+        raise Error, "Query error - use the error method to view it"
+      else
+        @response["hits"]["hits"]
+      end
+    end
+
+    def highlights(multiple: false)
+      hits.map do |hit|
+        hit_highlights(hit, multiple: multiple)
+      end
+    end
+
+    def with_highlights(multiple: false)
+      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
+
+    def misspellings?
+      @options[:misspellings]
+    end
+
+    def scroll_id
+      @response["_scroll_id"]
+    end
+
+    def scroll
+      raise Error, "Pass `scroll` option to the search method for scrolling" unless scroll_id
+
+      if block_given?
+        records = self
+        while records.any?
+          yield records
+          records = records.scroll
+        end
+
+        records.clear_scroll
+      else
+        begin
+          # TODO Active Support notifications for this scroll call
+          params = {
+            scroll: options[:scroll],
+            body: {scroll_id: scroll_id}
+          }
+          params[:opaque_id] = options[:opaque_id] if options[:opaque_id]
+          Results.new(@klass, Searchkick.client.scroll(params), @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
+        end
+      end
+    end
+
+    def clear_scroll
+      begin
+        # try to clear scroll
+        # not required as scroll will expire
+        # but there is a cost to open scrolls
+        Searchkick.client.clear_scroll({body: {scroll_id: scroll_id}})
+      rescue => e
+        raise e unless Searchkick.transport_error?(e)
+      end
+    end
+
+    private
+
+    attr_reader :klass, :options
+
+    def results
+      @results ||= with_hit.map(&:first)
+    end
+
+    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 = records.includes(included_relations)
+      end
+
+      if options[:scope_results]
+        records = options[:scope_results].call(records)
+      end
+
+      Searchkick.load_records(records, ids)
+    end
+
+    def combine_includes(result, inc)
+      if inc
+        if inc.is_a?(Array)
+          result.concat(inc)
+        else
+          result << inc
+        end
+      end
+    end
+
+    def base_field(k)
+      k.sub(/\.(analyzed|word_start|word_middle|word_end|text_start|text_middle|text_end|exact)\z/, "")
+    end
+
+    def hit_highlights(hit, multiple: false)
+      if hit["highlight"]
+        hit["highlight"].to_h { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }
+      else
+        {}
+      end
+    end
+  end
+end

data/searchkick-6.1.2/lib/searchkick/script.rb

@@ -0,0 +1,11 @@
+module Searchkick
+  class Script
+    attr_reader :source, :lang, :params
+
+    def initialize(source, lang: "painless", params: {})
+      @source = source
+      @lang = lang
+      @params = params
+    end
+  end
+end

data/searchkick-6.1.2/lib/searchkick/version.rb

@@ -0,0 +1,3 @@
+module Searchkick
+  VERSION = "6.1.2"
+end

data/searchkick-6.1.2/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