tiny-quick-gem 0.0.1

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

@@ -0,0 +1,57 @@
+# based on https://gist.github.com/mnutt/566725
+module Searchkick
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current[:searchkick_runtime] = value
+    end
+
+    def self.runtime
+      Thread.current[:searchkick_runtime] ||= 0
+    end
+
+    def self.reset_runtime
+      rt = runtime
+      self.runtime = 0
+      rt
+    end
+
+    def search(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+
+      index = payload[:query][:index].is_a?(Array) ? payload[:query][:index].join(",") : payload[:query][:index]
+      type = payload[:query][:type]
+      request_params = payload[:query].except(:index, :type, :body, :opaque_id)
+
+      params = []
+      request_params.each do |k, v|
+        params << "#{CGI.escape(k.to_s)}=#{CGI.escape(v.to_s)}"
+      end
+
+      debug "  #{color(name, YELLOW, bold: true)}  #{index}#{type ? "/#{type.join(',')}" : ''}/_search#{params.any? ? '?' + params.join('&') : nil} #{payload[:query][:body].to_json}"
+    end
+
+    def request(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+
+      debug "  #{color(name, YELLOW, bold: true)}  #{payload.except(:name).to_json}"
+    end
+
+    def multi_search(event)
+      self.class.runtime += event.duration
+      return unless logger.debug?
+
+      payload = event.payload
+      name = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+
+      debug "  #{color(name, YELLOW, bold: true)}  _msearch #{payload[:body]}"
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require "faraday"
+
+module Searchkick
+  class Middleware < Faraday::Middleware
+    def call(env)
+      path = env[:url].path.to_s
+      if path.end_with?("/_search")
+        env[:request][:timeout] = Searchkick.search_timeout
+      elsif path.end_with?("/_msearch")
+        # assume no concurrent searches for timeout for now
+        searches = env[:request_body].count("\n") / 2
+        # do not allow timeout to exceed Searchkick.timeout
+        timeout = [Searchkick.search_timeout * searches, Searchkick.timeout].min
+        env[:request][:timeout] = timeout
+      end
+      @app.call(env)
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Searchkick
+  module Model
+    def searchkick(**options)
+      options = Searchkick.model_options.deep_merge(options)
+
+      if options[:conversions]
+        Searchkick.warn("The `conversions` option is deprecated in favor of `conversions_v2`, which provides much better search performance. Upgrade to `conversions_v2` or rename `conversions` to `conversions_v1`")
+      end
+
+      if options.key?(:conversions_v1)
+        options[:conversions] = options.delete(:conversions_v1)
+      end
+
+      unknown_keywords = options.keys - [:_all, :_type, :batch_size, :callbacks, :callback_options, :case_sensitive, :conversions, :conversions_v2, :deep_paging, :default_fields,
+        :filterable, :geo_shape, :highlight, :ignore_above, :index_name, :index_prefix, :inheritance, :job_options, :knn, :language,
+        :locations, :mappings, :match, :max_result_window, :merge_mappings, :routing, :searchable, :search_synonyms, :settings, :similarity,
+        :special_characters, :stem, :stemmer, :stem_conversions, :stem_exclusion, :stemmer_override, :suggest, :synonyms, :text_end,
+        :text_middle, :text_start, :unscope, :word, :word_end, :word_middle, :word_start]
+      raise ArgumentError, "unknown keywords: #{unknown_keywords.join(", ")}" if unknown_keywords.any?
+
+      raise "Only call searchkick once per model" if respond_to?(:searchkick_index)
+
+      Searchkick.models << self
+
+      options[:_type] ||= -> { searchkick_index.klass_document_type(self, true) }
+      options[:class_name] = model_name.name
+
+      callbacks = options.key?(:callbacks) ? options[:callbacks] : :inline
+      unless [:inline, true, false, :async, :queue].include?(callbacks)
+        raise ArgumentError, "Invalid value for callbacks"
+      end
+      callback_options = (options[:callback_options] || {}).dup
+      callback_options[:if] = [-> { Searchkick.callbacks?(default: callbacks) }, callback_options[:if]].compact.flatten(1)
+
+      base = self
+
+      mod = Module.new
+      include(mod)
+      mod.module_eval do
+        def reindex(method_name = nil, mode: nil, refresh: false, ignore_missing: nil, job_options: nil)
+          self.class.searchkick_index.reindex([self], method_name: method_name, mode: mode, refresh: refresh, ignore_missing: ignore_missing, job_options: job_options, single: true)
+        end unless base.method_defined?(:reindex)
+
+        def similar(**options)
+          self.class.searchkick_index.similar_record(self, **options)
+        end unless base.method_defined?(:similar)
+
+        def search_data
+          data = respond_to?(:to_hash) ? to_hash : serializable_hash
+          data.delete("id")
+          data.delete("_id")
+          data.delete("_type")
+          data
+        end unless base.method_defined?(:search_data)
+
+        def should_index?
+          true
+        end unless base.method_defined?(:should_index?)
+      end
+
+      class_eval do
+        cattr_reader :searchkick_options, :searchkick_klass, instance_reader: false
+
+        class_variable_set :@@searchkick_options, options.dup
+        class_variable_set :@@searchkick_klass, self
+        class_variable_set :@@searchkick_index_cache, Searchkick::IndexCache.new
+
+        class << self
+          def searchkick_search(term = "*", **options, &block)
+            if Searchkick.relation?(self)
+              raise Searchkick::Error, "search must be called on model, not relation"
+            end
+
+            Searchkick.search(term, model: self, **options, &block)
+          end
+          alias_method Searchkick.search_method_name, :searchkick_search if Searchkick.search_method_name
+
+          def searchkick_index(name: nil)
+            index_name = name || searchkick_klass.searchkick_index_name
+            index_name = index_name.call if index_name.respond_to?(:call)
+            index_cache = class_variable_get(:@@searchkick_index_cache)
+            index_cache.fetch(index_name) { Searchkick::Index.new(index_name, searchkick_options) }
+          end
+          alias_method :search_index, :searchkick_index unless method_defined?(:search_index)
+
+          def searchkick_reindex(method_name = nil, **options)
+            searchkick_index.reindex(self, method_name: method_name, **options)
+          end
+          alias_method :reindex, :searchkick_reindex unless method_defined?(:reindex)
+
+          def searchkick_index_options
+            searchkick_index.index_options
+          end
+
+          def searchkick_index_name
+            @searchkick_index_name ||= begin
+              options = class_variable_get(:@@searchkick_options)
+              if options[:index_name]
+                options[:index_name]
+              elsif options[:index_prefix].respond_to?(:call)
+                -> { [options[:index_prefix].call, model_name.plural, Searchkick.env, Searchkick.index_suffix].compact.join("_") }
+              else
+                [options.key?(:index_prefix) ? options[:index_prefix] : Searchkick.index_prefix, model_name.plural, Searchkick.env, Searchkick.index_suffix].compact.join("_")
+              end
+            end
+          end
+        end
+
+        # always add callbacks, even when callbacks is false
+        # so Model.callbacks block can be used
+        if respond_to?(:after_commit)
+          after_commit :reindex, **callback_options
+        elsif respond_to?(:after_save)
+          after_save :reindex, **callback_options
+          after_destroy :reindex, **callback_options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Searchkick
+  class MultiSearch
+    attr_reader :queries
+
+    def initialize(queries, opaque_id: nil)
+      @queries = queries
+      @opaque_id = opaque_id
+    end
+
+    def perform
+      if queries.any?
+        perform_search(queries)
+      end
+    end
+
+    private
+
+    def perform_search(search_queries, perform_retry: true)
+      params = {
+        body: search_queries.flat_map { |q| [q.params.except(:body), q.body] }
+      }
+      params[:opaque_id] = @opaque_id if @opaque_id
+      responses = client.msearch(params)["responses"]
+
+      retry_queries = []
+      search_queries.each_with_index do |query, i|
+        if perform_retry && query.retry_misspellings?(responses[i])
+          query.send(:prepare) # okay, since we don't want to expose this method outside Searchkick
+          retry_queries << query
+        else
+          query.handle_response(responses[i])
+        end
+      end
+
+      if retry_queries.any?
+        perform_search(retry_queries, perform_retry: false)
+      end
+
+      search_queries
+    end
+
+    def client
+      Searchkick.client
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Searchkick
+  class ProcessBatchJob < Searchkick.parent_job.constantize
+    queue_as { Searchkick.queue_name }
+
+    def perform(class_name:, record_ids:, index_name: nil)
+      model = Searchkick.load_model(class_name)
+      index = model.searchkick_index(name: index_name)
+
+      items =
+        record_ids.map do |r|
+          parts = r.split(/(?<!\|)\|(?!\|)/, 2)
+            .map { |v| v.gsub("||", "|") }
+          {id: parts[0], routing: parts[1]}
+        end
+
+      relation = Searchkick.scope(model)
+      RecordIndexer.new(index).reindex_items(relation, items, method_name: nil, ignore_missing: nil)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Searchkick
+  class ProcessQueueJob < Searchkick.parent_job.constantize
+    queue_as { Searchkick.queue_name }
+
+    def perform(class_name:, index_name: nil, inline: false, job_options: nil)
+      model = Searchkick.load_model(class_name)
+      index = model.searchkick_index(name: index_name)
+      limit = model.searchkick_options[:batch_size] || 1000
+      job_options = (model.searchkick_options[:job_options] || {}).merge(job_options || {})
+
+      loop do
+        record_ids = index.reindex_queue.reserve(limit: limit)
+        if record_ids.any?
+          batch_options = {
+            class_name: class_name,
+            record_ids: record_ids.uniq,
+            index_name: index_name
+          }
+
+          if inline
+            # use new.perform to avoid excessive logging
+            Searchkick::ProcessBatchJob.new.perform(**batch_options)
+          else
+            Searchkick::ProcessBatchJob.set(job_options).perform_later(**batch_options)
+          end
+
+          # TODO when moving to reliable queuing, mark as complete
+        end
+        break unless record_ids.size == limit
+      end
+    end
+  end
+end