searchkick_evichat 0.0.2

data/lib/searchkick/record_data.rb

@@ -0,0 +1,128 @@
+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
+
+    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
+
+    private
+
+    def record_data
+      data = {
+        _index: index.name,
+        _id: search_id,
+        _type: document_type
+      }
+      data[:_routing] = record.search_routing if record.respond_to?(:search_routing)
+      data
+    end
+
+    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
+
+      # hack to prevent generator field doesn't exist error
+      if !partial_reindex
+        index.suggest_fields.each do |field|
+          if !source[field] && !source[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/lib/searchkick/record_indexer.rb

@@ -0,0 +1,59 @@
+module Searchkick
+  class RecordIndexer
+    attr_reader :record, :index
+
+    def initialize(record)
+      @record = record
+      @index = record.class.searchkick_index
+    end
+
+    def reindex(method_name = nil, refresh: false, mode: nil)
+      unless [true, nil, :async, :queue].include?(mode)
+        raise ArgumentError, "Invalid value for mode"
+      end
+
+      mode ||= Searchkick.callbacks_value || index.options[:callbacks] || true
+
+      case mode
+      when :queue
+        if method_name
+          raise Searchkick::Error, "Partial reindex not supported with queue option"
+        end
+
+        index.reindex_queue.push(record.id.to_s)
+      when :async
+        unless defined?(ActiveJob)
+          raise Searchkick::Error, "Active Job not found"
+        end
+
+        Searchkick::ReindexV2Job.perform_later(
+          record.class.name,
+          record.id.to_s,
+          method_name ? method_name.to_s : nil
+        )
+      else # bulk, true
+        reindex_record(method_name)
+
+        index.refresh if refresh
+      end
+    end
+
+    private
+
+    def reindex_record(method_name)
+      if record.destroyed? || !record.persisted? || !record.should_index?
+        begin
+          index.remove(record)
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          # do nothing
+        end
+      else
+        if method_name
+          index.update_record(record, method_name)
+        else
+          index.store(record)
+        end
+      end
+    end
+  end
+end

data/lib/searchkick/reindex_queue.rb

@@ -0,0 +1,38 @@
+module Searchkick
+  class ReindexQueue
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+
+      raise Searchkick::Error, "Searchkick.redis not set" unless Searchkick.redis
+    end
+
+    def push(record_id)
+      Searchkick.with_redis { |r| r.lpush(redis_key, record_id) }
+    end
+
+    # TODO use reliable queuing
+    def reserve(limit: 1000)
+      record_ids = Set.new
+      while record_ids.size < limit && (record_id = Searchkick.with_redis { |r| r.rpop(redis_key) })
+        record_ids << record_id
+      end
+      record_ids.to_a
+    end
+
+    def clear
+      Searchkick.with_redis { |r| r.del(redis_key) }
+    end
+
+    def length
+      Searchkick.with_redis { |r| r.llen(redis_key) }
+    end
+
+    private
+
+    def redis_key
+      "searchkick:reindex_queue:#{name}"
+    end
+  end
+end

data/lib/searchkick/reindex_v2_job.rb

@@ -0,0 +1,36 @@
+module Searchkick
+  class ReindexV2Job < ActiveJob::Base
+    RECORD_NOT_FOUND_CLASSES = [
+      "ActiveRecord::RecordNotFound",
+      "Mongoid::Errors::DocumentNotFound",
+      "NoBrainer::Error::DocumentNotFound",
+      "Cequel::Record::RecordNotFound"
+    ]
+
+    queue_as { Searchkick.queue_name }
+
+    def perform(klass, id, method_name = nil)
+      model = klass.constantize
+      record =
+        begin
+          if model.respond_to?(:unscoped)
+            model.unscoped.find(id)
+          else
+            model.find(id)
+          end
+        rescue => e
+          # check by name rather than rescue directly so we don't need
+          # to determine which classes are defined
+          raise e unless RECORD_NOT_FOUND_CLASSES.include?(e.class.name)
+          nil
+        end
+
+      unless record
+        record = model.new
+        record.id = id
+      end
+
+      RecordIndexer.new(record).reindex(method_name, mode: true)
+    end
+  end
+end

data/lib/searchkick/results.rb

@@ -0,0 +1,235 @@
+require "forwardable"
+
+module Searchkick
+  class Results
+    include Enumerable
+    extend Forwardable
+
+    attr_reader :klass, :response, :options
+
+    def_delegators :results, :each, :any?, :empty?, :size, :length, :slice, :[], :to_ary
+
+    def initialize(klass, response, options = {})
+      @klass = klass
+      @response = response
+      @options = options
+    end
+
+    def results
+      @results ||= begin
+        if options[:load]
+          # results can have different types
+          results = {}
+
+          hits.group_by { |hit, _| hit["_type"] }.each do |type, grouped_hits|
+            klass = (!options[:index_name] && @klass) || type.camelize.constantize
+            results[type] = results_query(klass, grouped_hits).to_a.index_by { |r| r.id.to_s }
+          end
+
+          # sort
+          hits.map do |hit|
+            result = results[hit["_type"]][hit["_id"].to_s]
+            if result && !(options[:load].is_a?(Hash) && options[:load][:dumpable])
+              if hit["highlight"] && !result.respond_to?(:search_highlights)
+                highlights = Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, v.first] }]
+                result.define_singleton_method(:search_highlights) do
+                  highlights
+                end
+              end
+            end
+            result
+          end.compact
+        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"]
+              highlight = Hash[hit["highlight"].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
+
+            result["id"] ||= result["_id"] # needed for legacy reasons
+            HashWrapper.new(result)
+          end
+        end
+      end
+    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[:term] == "*"
+        []
+      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
+      klass.model_name
+    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
+      response["hits"]["total"]
+    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 Searchkick::Error, "Query error - use the error method to view it"
+      else
+        @response["hits"]["hits"]
+      end
+    end
+
+    def with_hit
+      results.zip(hits)
+    end
+
+    def highlights(multiple: false)
+      hits.map do |hit|
+        Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, multiple ? v : v.first] }]
+      end
+    end
+
+    def with_highlights(multiple: false)
+      results.zip(highlights(multiple: multiple))
+    end
+
+    def misspellings?
+      @options[:misspellings]
+    end
+
+    private
+
+    def results_query(records, hits)
+      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
+      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
+  end
+end