tiny-quick-gem 0.0.1

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

@@ -0,0 +1,7 @@
+module Searchkick
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "tasks/searchkick.rake"
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module Searchkick
+  class RecordData
+    TYPE_KEYS = ["type", :type]
+
+    attr_reader :index, :record
+
+    def initialize(index, record)
+      @index = index
+      @record = record
+    end
+
+    def index_data
+      data = record_data
+      data[:data] = search_data
+      {index: data}
+    end
+
+    def update_data(method_name)
+      data = record_data
+      data[:data] = {doc: search_data(method_name)}
+      {update: data}
+    end
+
+    def delete_data
+      {delete: record_data}
+    end
+
+    # custom id can be useful for load: false
+    def search_id
+      id = record.respond_to?(:search_document_id) ? record.search_document_id : record.id
+      id.is_a?(Numeric) ? id : id.to_s
+    end
+
+    def document_type(ignore_type = false)
+      index.klass_document_type(record.class, ignore_type)
+    end
+
+    def record_data
+      data = {
+        _index: index.name,
+        _id: search_id
+      }
+      data[:routing] = record.search_routing if record.respond_to?(:search_routing)
+      data
+    end
+
+    private
+
+    def search_data(method_name = nil)
+      partial_reindex = !method_name.nil?
+
+      source = record.send(method_name || :search_data)
+
+      # conversions
+      index.conversions_fields.each do |conversions_field|
+        if source[conversions_field]
+          source[conversions_field] = source[conversions_field].map { |k, v| {query: k, count: v} }
+        end
+      end
+
+      index.conversions_v2_fields.each do |conversions_field|
+        key = source.key?(conversions_field) ? conversions_field : conversions_field.to_sym
+        if !partial_reindex || source[key]
+          if index.options[:case_sensitive]
+            source[key] =
+              (source[key] || {}).reduce(Hash.new(0)) do |memo, (k, v)|
+                memo[k.to_s.gsub(".", "*")] += v
+                memo
+              end
+          else
+            source[key] =
+              (source[key] || {}).reduce(Hash.new(0)) do |memo, (k, v)|
+                memo[k.to_s.downcase.gsub(".", "*")] += v
+                memo
+              end
+          end
+        end
+      end
+
+      # hack to prevent generator field doesn't exist error
+      if !partial_reindex
+        index.suggest_fields.each do |field|
+          if !source.key?(field) && !source.key?(field.to_sym)
+            source[field] = nil
+          end
+        end
+      end
+
+      # locations
+      index.locations_fields.each do |field|
+        if source[field]
+          if !source[field].is_a?(Hash) && (source[field].first.is_a?(Array) || source[field].first.is_a?(Hash))
+            # multiple locations
+            source[field] = source[field].map { |a| location_value(a) }
+          else
+            source[field] = location_value(source[field])
+          end
+        end
+      end
+
+      if index.options[:inheritance]
+        if !TYPE_KEYS.any? { |tk| source.key?(tk) }
+          source[:type] = document_type(true)
+        end
+      end
+
+      cast_big_decimal(source)
+
+      source
+    end
+
+    def location_value(value)
+      if value.is_a?(Array)
+        value.map(&:to_f).reverse
+      elsif value.is_a?(Hash)
+        {lat: value[:lat].to_f, lon: value[:lon].to_f}
+      else
+        value
+      end
+    end
+
+    # change all BigDecimal values to floats due to
+    # https://github.com/rails/rails/issues/6033
+    # possible loss of precision :/
+    def cast_big_decimal(obj)
+      case obj
+      when BigDecimal
+        obj.to_f
+      when Hash
+        obj.each do |k, v|
+          # performance
+          if v.is_a?(BigDecimal)
+            obj[k] = v.to_f
+          elsif v.is_a?(Enumerable)
+            obj[k] = cast_big_decimal(v)
+          end
+        end
+      when Enumerable
+        obj.map do |v|
+          cast_big_decimal(v)
+        end
+      else
+        obj
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module Searchkick
+  class RecordIndexer
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+
+    def reindex(records, mode:, method_name:, ignore_missing:, full: false, single: false, job_options: nil)
+      # prevents exists? check if records is a relation
+      records = records.to_a
+      return if records.empty?
+
+      case mode
+      when :async
+        unless defined?(ActiveJob)
+          raise Error, "Active Job not found"
+        end
+
+        job_options ||= {}
+
+        # only add if set for backwards compatibility
+        extra_options = {}
+        if ignore_missing
+          extra_options[:ignore_missing] = ignore_missing
+        end
+
+        # we could likely combine ReindexV2Job, BulkReindexJob, and ProcessBatchJob
+        # but keep them separate for now
+        if single
+          record = records.first
+
+          # always pass routing in case record is deleted
+          # before the async job runs
+          if record.respond_to?(:search_routing)
+            routing = record.search_routing
+          end
+
+          Searchkick::ReindexV2Job.set(**job_options).perform_later(
+            record.class.name,
+            record.id.to_s,
+            method_name ? method_name.to_s : nil,
+            routing: routing,
+            index_name: index.name,
+            **extra_options
+          )
+        else
+          Searchkick::BulkReindexJob.set(**job_options).perform_later(
+            class_name: records.first.class.searchkick_options[:class_name],
+            record_ids: records.map { |r| r.id.to_s },
+            index_name: index.name,
+            method_name: method_name ? method_name.to_s : nil,
+            **extra_options
+          )
+        end
+      when :queue
+        if method_name
+          raise Error, "Partial reindex not supported with queue option"
+        end
+
+        index.reindex_queue.push_records(records)
+      when true, :inline
+        index_records, other_records = records.partition { |r| index_record?(r) }
+        import_inline(index_records, !full ? other_records : [], method_name: method_name, ignore_missing: ignore_missing, single: single)
+      else
+        raise ArgumentError, "Invalid value for mode"
+      end
+
+      # return true like model and relation reindex for now
+      true
+    end
+
+    def reindex_items(klass, items, method_name:, ignore_missing:, single: false)
+      routing = items.to_h { |r| [r[:id], r[:routing]] }
+      record_ids = routing.keys
+
+      relation = Searchkick.load_records(klass, record_ids)
+      # call search_import even for single records for nested associations
+      relation = relation.search_import if relation.respond_to?(:search_import)
+      records = relation.select(&:should_index?)
+
+      # determine which records to delete
+      delete_ids = record_ids - records.map { |r| r.id.to_s }
+      delete_records =
+        delete_ids.map do |id|
+          construct_record(klass, id, routing[id])
+        end
+
+      import_inline(records, delete_records, method_name: method_name, ignore_missing: ignore_missing, single: single)
+    end
+
+    private
+
+    def index_record?(record)
+      record.persisted? && !record.destroyed? && record.should_index?
+    end
+
+    # import in single request with retries
+    def import_inline(index_records, delete_records, method_name:, ignore_missing:, single:)
+      return if index_records.empty? && delete_records.empty?
+
+      maybe_bulk(index_records, delete_records, method_name, single) do
+        if index_records.any?
+          if method_name
+            index.bulk_update(index_records, method_name, ignore_missing: ignore_missing)
+          else
+            index.bulk_index(index_records)
+          end
+        end
+
+        if delete_records.any?
+          index.bulk_delete(delete_records)
+        end
+      end
+    end
+
+    def maybe_bulk(index_records, delete_records, method_name, single)
+      if Searchkick.callbacks_value == :bulk
+        yield
+      else
+        # set action and data
+        action =
+          if single && index_records.empty?
+            "Remove"
+          elsif method_name
+            "Update"
+          else
+            single ? "Store" : "Import"
+          end
+        record = index_records.first || delete_records.first
+        name = record.class.searchkick_klass.name
+        message = lambda do |event|
+          event[:name] = "#{name} #{action}"
+          if single
+            event[:id] = index.search_id(record)
+          else
+            event[:count] = index_records.size + delete_records.size
+          end
+        end
+
+        with_retries do
+          Searchkick.callbacks(:bulk, message: message) do
+            yield
+          end
+        end
+      end
+    end
+
+    def construct_record(klass, id, routing)
+      record = klass.new
+      record.id = id
+      if routing
+        record.define_singleton_method(:search_routing) do
+          routing
+        end
+      end
+      record
+    end
+
+    def with_retries
+      retries = 0
+
+      begin
+        yield
+      rescue Faraday::ClientError => e
+        if retries < 1
+          retries += 1
+          retry
+        end
+        raise e
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+module Searchkick
+  class ReindexQueue
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+
+      raise Error, "Searchkick.redis not set" unless Searchkick.redis
+    end
+
+    # supports single and multiple ids
+    def push(record_ids)
+      Searchkick.with_redis { |r| r.call("LPUSH", redis_key, record_ids) }
+    end
+
+    def push_records(records)
+      record_ids =
+        records.map do |record|
+          # always pass routing in case record is deleted
+          # before the queue job runs
+          if record.respond_to?(:search_routing)
+            routing = record.search_routing
+          end
+
+          # escape pipe with double pipe
+          value = escape(record.id.to_s)
+          value = "#{value}|#{escape(routing)}" if routing
+          value
+        end
+
+      push(record_ids)
+    end
+
+    # TODO use reliable queuing
+    def reserve(limit: 1000)
+      Searchkick.with_redis { |r| r.call("RPOP", redis_key, limit) }.to_a
+    end
+
+    def clear
+      Searchkick.with_redis { |r| r.call("DEL", redis_key) }
+    end
+
+    def length
+      Searchkick.with_redis { |r| r.call("LLEN", redis_key) }
+    end
+
+    private
+
+    def redis_key
+      "searchkick:reindex_queue:#{name}"
+    end
+
+    def escape(value)
+      value.to_s.gsub("|", "||")
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Searchkick
+  class ReindexV2Job < Searchkick.parent_job.constantize
+    queue_as { Searchkick.queue_name }
+
+    def perform(class_name, id, method_name = nil, routing: nil, index_name: nil, ignore_missing: nil)
+      model = Searchkick.load_model(class_name, allow_child: true)
+      index = model.searchkick_index(name: index_name)
+      # use should_index? to decide whether to index (not default scope)
+      # just like saving inline
+      # could use Searchkick.scope() in future
+      # but keep for now for backwards compatibility
+      model = model.unscoped if model.respond_to?(:unscoped)
+      items = [{id: id, routing: routing}]
+      RecordIndexer.new(index).reindex_items(model, items, method_name: method_name, ignore_missing: ignore_missing, single: true)
+    end
+  end
+end