searchkick 2.3.2 → 5.2.1

data/lib/searchkick/logging.rb

@@ -1,242 +0,0 @@
-# based on https://gist.github.com/mnutt/566725
-require "active_support/core_ext/module/attr_internal"
-
-module Searchkick
-  module QueryWithInstrumentation
-    def execute_search
-      name = searchkick_klass ? "#{searchkick_klass.name} Search" : "Search"
-      event = {
-        name: name,
-        query: params
-      }
-      ActiveSupport::Notifications.instrument("search.searchkick", event) do
-        super
-      end
-    end
-  end
-
-  module IndexWithInstrumentation
-    def store(record)
-      event = {
-        name: "#{record.searchkick_klass.name} Store",
-        id: search_id(record)
-      }
-      if Searchkick.callbacks_value == :bulk
-        super
-      else
-        ActiveSupport::Notifications.instrument("request.searchkick", event) do
-          super
-        end
-      end
-    end
-
-    def remove(record)
-      name = record && record.searchkick_klass ? "#{record.searchkick_klass.name} Remove" : "Remove"
-      event = {
-        name: name,
-        id: search_id(record)
-      }
-      if Searchkick.callbacks_value == :bulk
-        super
-      else
-        ActiveSupport::Notifications.instrument("request.searchkick", event) do
-          super
-        end
-      end
-    end
-
-    def update_record(record, method_name)
-      event = {
-        name: "#{record.searchkick_klass.name} Update",
-        id: search_id(record)
-      }
-      if Searchkick.callbacks_value == :bulk
-        super
-      else
-        ActiveSupport::Notifications.instrument("request.searchkick", event) do
-          super
-        end
-      end
-    end
-
-    def bulk_index(records)
-      if records.any?
-        event = {
-          name: "#{records.first.searchkick_klass.name} Import",
-          count: records.size
-        }
-        event[:id] = search_id(records.first) if records.size == 1
-        if Searchkick.callbacks_value == :bulk
-          super
-        else
-          ActiveSupport::Notifications.instrument("request.searchkick", event) do
-            super
-          end
-        end
-      end
-    end
-    alias_method :import, :bulk_index
-
-    def bulk_update(records, *args)
-      if records.any?
-        event = {
-          name: "#{records.first.searchkick_klass.name} Update",
-          count: records.size
-        }
-        event[:id] = search_id(records.first) if records.size == 1
-        if Searchkick.callbacks_value == :bulk
-          super
-        else
-          ActiveSupport::Notifications.instrument("request.searchkick", event) do
-            super
-          end
-        end
-      end
-    end
-
-    def bulk_delete(records)
-      if records.any?
-        event = {
-          name: "#{records.first.searchkick_klass.name} Delete",
-          count: records.size
-        }
-        event[:id] = search_id(records.first) if records.size == 1
-        if Searchkick.callbacks_value == :bulk
-          super
-        else
-          ActiveSupport::Notifications.instrument("request.searchkick", event) do
-            super
-          end
-        end
-      end
-    end
-  end
-
-  module IndexerWithInstrumentation
-    def perform
-      if Searchkick.callbacks_value == :bulk
-        event = {
-          name: "Bulk",
-          count: queued_items.size
-        }
-        ActiveSupport::Notifications.instrument("request.searchkick", event) do
-          super
-        end
-      else
-        super
-      end
-    end
-  end
-
-  module SearchkickWithInstrumentation
-    def multi_search(searches, **options)
-      event = {
-        name: "Multi Search",
-        body: searches.flat_map { |q| [q.params.except(:body).to_json, q.body.to_json] }.map { |v| "#{v}\n" }.join
-      }
-      ActiveSupport::Notifications.instrument("multi_search.searchkick", event) do
-        super
-      end
-    end
-  end
-
-  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/log_subscriber.rb
-  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)"
-      type = payload[:query][:type]
-      index = payload[:query][:index].is_a?(Array) ? payload[:query][:index].join(",") : payload[:query][:index]
-
-      # no easy way to tell which host the client will use
-      host = Searchkick.client.transport.hosts.first
-      debug "  #{color(name, YELLOW, true)}  curl #{host[:protocol]}://#{host[:host]}:#{host[:port]}/#{CGI.escape(index)}#{type ? "/#{type.map { |t| CGI.escape(t) }.join(',')}" : ''}/_search?pretty -d '#{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, 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)"
-
-      # no easy way to tell which host the client will use
-      host = Searchkick.client.transport.hosts.first
-      debug "  #{color(name, YELLOW, true)}  curl #{host[:protocol]}://#{host[:host]}:#{host[:port]}/_msearch?pretty -d '#{payload[:body]}'"
-    end
-  end
-
-  # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/railties/controller_runtime.rb
-  module ControllerRuntime
-    extend ActiveSupport::Concern
-
-    protected
-
-    attr_internal :searchkick_runtime
-
-    def process_action(action, *args)
-      # We also need to reset the runtime before each action
-      # because of queries in middleware or in cases we are streaming
-      # and it won't be cleaned up by the method below.
-      Searchkick::LogSubscriber.reset_runtime
-      super
-    end
-
-    def cleanup_view_runtime
-      searchkick_rt_before_render = Searchkick::LogSubscriber.reset_runtime
-      runtime = super
-      searchkick_rt_after_render = Searchkick::LogSubscriber.reset_runtime
-      self.searchkick_runtime = searchkick_rt_before_render + searchkick_rt_after_render
-      runtime - searchkick_rt_after_render
-    end
-
-    def append_info_to_payload(payload)
-      super
-      payload[:searchkick_runtime] = (searchkick_runtime || 0) + Searchkick::LogSubscriber.reset_runtime
-    end
-
-    module ClassMethods
-      def log_process_action(payload)
-        messages = super
-        runtime = payload[:searchkick_runtime]
-        messages << ("Searchkick: %.1fms" % runtime.to_f) if runtime.to_f > 0
-        messages
-      end
-    end
-  end
-end
-Searchkick::Query.send(:prepend, Searchkick::QueryWithInstrumentation)
-Searchkick::Index.send(:prepend, Searchkick::IndexWithInstrumentation)
-Searchkick::Indexer.send(:prepend, Searchkick::IndexerWithInstrumentation)
-Searchkick.singleton_class.send(:prepend, Searchkick::SearchkickWithInstrumentation)
-Searchkick::LogSubscriber.attach_to :searchkick
-ActiveSupport.on_load(:action_controller) do
-  include Searchkick::ControllerRuntime
-end

data/lib/searchkick/tasks.rb

@@ -1,33 +0,0 @@
-require "rake"
-
-namespace :searchkick do
-  desc "reindex model"
-  task reindex: :environment do
-    if ENV["CLASS"]
-      klass = ENV["CLASS"].constantize rescue nil
-      if klass
-        klass.reindex
-      else
-        abort "Could not find class: #{ENV['CLASS']}"
-      end
-    else
-      abort "USAGE: rake searchkick:reindex CLASS=Product"
-    end
-  end
-
-  if defined?(Rails)
-
-    namespace :reindex do
-      desc "reindex all models"
-      task all: :environment do
-        Rails.application.eager_load!
-        Searchkick.models.each do |model|
-          puts "Reindexing #{model.name}..."
-          model.reindex
-        end
-        puts "Reindex complete"
-      end
-    end
-
-  end
-end

data/searchkick.gemspec

@@ -1,28 +0,0 @@
-# coding: utf-8
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "searchkick/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "searchkick"
-  spec.version       = Searchkick::VERSION
-  spec.authors       = ["Andrew Kane"]
-  spec.email         = ["andrew@chartkick.com"]
-  spec.description   = "Intelligent search made easy"
-  spec.summary       = "Searchkick learns what your users are looking for. As more people search, it gets smarter and the results get better. It’s friendly for developers - and magical for your users."
-  spec.homepage      = "https://github.com/ankane/searchkick"
-  spec.license       = "MIT"
-
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features|benchmark)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "activemodel", ">= 4.1"
-  spec.add_dependency "elasticsearch", ">= 1"
-  spec.add_dependency "hashie"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-end

data/test/aggs_test.rb

@@ -1,197 +0,0 @@
-require_relative "test_helper"
-
-class AggsTest < Minitest::Test
-  def setup
-    super
-    store [
-      {name: "Product Show", latitude: 37.7833, longitude: 12.4167, store_id: 1, in_stock: true, color: "blue", price: 21, created_at: 2.days.ago},
-      {name: "Product Hide", latitude: 29.4167, longitude: -98.5000, store_id: 2, in_stock: false, color: "green", price: 25, created_at: 2.days.from_now},
-      {name: "Product B", latitude: 43.9333, longitude: -122.4667, store_id: 2, in_stock: false, color: "red", price: 5, created_at: Time.now},
-      {name: "Foo", latitude: 43.9333, longitude: 12.4667, store_id: 3, in_stock: false, color: "yellow", price: 15, created_at: Time.now}
-    ]
-  end
-
-  def test_basic
-    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: [:store_id])
-  end
-
-  def test_where
-    assert_equal ({1 => 1}), store_agg(aggs: {store_id: {where: {in_stock: true}}})
-  end
-
-  def test_order
-    agg = Product.search("Product", aggs: {color: {order: {"_term" => "desc"}}}).aggs["color"]
-    assert_equal %w(red green blue), agg["buckets"].map { |b| b["key"] }
-  end
-
-  def test_field
-    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: {store_id: {}})
-    assert_equal ({1 => 1, 2 => 2}), store_agg(aggs: {store_id: {field: "store_id"}})
-    assert_equal ({1 => 1, 2 => 2}), store_agg({aggs: {store_id_new: {field: "store_id"}}}, "store_id_new")
-  end
-
-  def test_min_doc_count
-    assert_equal ({2 => 2}), store_agg(aggs: {store_id: {min_doc_count: 2}})
-  end
-
-  def test_no_aggs
-    assert_nil Product.search("*").aggs
-  end
-
-  def test_limit
-    agg = Product.search("Product", aggs: {store_id: {limit: 1}}).aggs["store_id"]
-    assert_equal 1, agg["buckets"].size
-    # assert_equal 3, agg["doc_count"]
-    assert_equal(1, agg["sum_other_doc_count"])
-  end
-
-  def test_ranges
-    price_ranges = [{to: 10}, {from: 10, to: 20}, {from: 20}]
-    agg = Product.search("Product", aggs: {price: {ranges: price_ranges}}).aggs["price"]
-
-    assert_equal 3, agg["buckets"].size
-    assert_equal 10.0, agg["buckets"][0]["to"]
-    assert_equal 20.0, agg["buckets"][2]["from"]
-    assert_equal 1, agg["buckets"][0]["doc_count"]
-    assert_equal 0, agg["buckets"][1]["doc_count"]
-    assert_equal 2, agg["buckets"][2]["doc_count"]
-  end
-
-  def test_date_ranges
-    ranges = [{to: 1.day.ago}, {from: 1.day.ago, to: 1.day.from_now}, {from: 1.day.from_now}]
-    agg = Product.search("Product", aggs: {created_at: {date_ranges: ranges}}).aggs["created_at"]
-
-    assert_equal 1, agg["buckets"][0]["doc_count"]
-    assert_equal 1, agg["buckets"][1]["doc_count"]
-    assert_equal 1, agg["buckets"][2]["doc_count"]
-  end
-
-  def test_query_where
-    assert_equal ({1 => 1}), store_agg(where: {in_stock: true}, aggs: [:store_id])
-  end
-
-  def test_two_wheres
-    assert_equal ({2 => 1}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false}}})
-  end
-
-  def test_where_override
-    assert_equal ({}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false, color: "blue"}}})
-    assert_equal ({2 => 1}), store_agg(where: {color: "blue"}, aggs: {store_id: {where: {in_stock: false, color: "red"}}})
-  end
-
-  def test_skip
-    assert_equal ({1 => 1, 2 => 2}), store_agg(where: {store_id: 2}, aggs: [:store_id])
-  end
-
-  def test_skip_complex
-    assert_equal ({1 => 1, 2 => 1}), store_agg(where: {store_id: 2, price: {gt: 5}}, aggs: [:store_id])
-  end
-
-  def test_multiple
-    assert_equal ({"store_id" => {1 => 1, 2 => 2}, "color" => {"blue" => 1, "green" => 1, "red" => 1}}), store_multiple_aggs(aggs: [:store_id, :color])
-  end
-
-  def test_smart_aggs_false
-    assert_equal ({2 => 2}), store_agg(where: {color: "red"}, aggs: {store_id: {where: {in_stock: false}}}, smart_aggs: false)
-    assert_equal ({2 => 2}), store_agg(where: {color: "blue"}, aggs: {store_id: {where: {in_stock: false}}}, smart_aggs: false)
-  end
-
-  def test_aggs_group_by_date
-    store [{name: "Old Product", created_at: 3.years.ago}]
-    products =
-      Product.search("Product", {
-        where: {
-          created_at: {lt: Time.now}
-        },
-        aggs: {
-          products_per_year: {
-            date_histogram: {
-              field: :created_at,
-              interval: :year
-            }
-          }
-        }
-      })
-
-    assert_equal 4, products.aggs["products_per_year"]["buckets"].size
-  end
-
-  def test_aggs_avg
-    products =
-      Product.search("*", {
-        aggs: {
-          avg_price: {
-            avg: {
-              field: :price
-            }
-          }
-        }
-      })
-    assert_equal 16.5, products.aggs["avg_price"]["value"]
-  end
-
-  def test_aggs_cardinality
-    products =
-      Product.search("*", {
-        aggs: {
-          total_stores: {
-            cardinality: {
-              field: :store_id
-            }
-          }
-        }
-      })
-    assert_equal 3, products.aggs["total_stores"]["value"]
-  end
-
-  def test_aggs_min_max
-    products =
-      Product.search("*", {
-        aggs: {
-          min_price: {
-            min: {
-              field: :price
-            }
-          },
-          max_price: {
-            max: {
-              field: :price
-            }
-          }
-        }
-      })
-    assert_equal 5, products.aggs["min_price"]["value"]
-    assert_equal 25, products.aggs["max_price"]["value"]
-  end
-
-  def test_aggs_sum
-    products =
-      Product.search("*", {
-        aggs: {
-          sum_price: {
-            sum: {
-              field: :price
-            }
-          }
-        }
-      })
-    assert_equal 66, products.aggs["sum_price"]["value"]
-  end
-
-  protected
-
-  def buckets_as_hash(agg)
-    Hash[agg["buckets"].map { |v| [v["key"], v["doc_count"]] }]
-  end
-
-  def store_agg(options, agg_key = "store_id")
-    buckets = Product.search("Product", options).aggs[agg_key]
-    buckets_as_hash(buckets)
-  end
-
-  def store_multiple_aggs(options)
-    Hash[Product.search("Product", options).aggs.map do |field, filtered_agg|
-      [field, buckets_as_hash(filtered_agg)]
-    end]
-  end
-end

data/test/autocomplete_test.rb

@@ -1,75 +0,0 @@
-require_relative "test_helper"
-
-class AutocompleteTest < Minitest::Test
-  def test_autocomplete
-    store_names ["Hummus"]
-    assert_search "hum", ["Hummus"], match: :text_start
-  end
-
-  def test_autocomplete_two_words
-    store_names ["Organic Hummus"]
-    assert_search "hum", [], match: :text_start
-  end
-
-  def test_autocomplete_fields
-    store_names ["Hummus"]
-    assert_search "hum", ["Hummus"], match: :text_start, fields: [:name]
-  end
-
-  def test_text_start
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_start}]
-    assert_search "in the world", [], fields: [{name: :text_start}]
-  end
-
-  def test_text_middle
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
-    assert_search "n the wor", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
-    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
-    assert_search "world carmen", [], fields: [{name: :text_middle}]
-  end
-
-  def test_text_end
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_end}]
-    assert_search "carmen san", [], fields: [{name: :text_end}]
-  end
-
-  def test_word_start
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "car san wor", ["Where in the World is Carmen San Diego"], fields: [{name: :word_start}]
-  end
-
-  def test_word_middle
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "orl", ["Where in the World is Carmen San Diego"], fields: [{name: :word_middle}]
-  end
-
-  def test_word_end
-    store_names ["Where in the World is Carmen San Diego"]
-    assert_search "rld men ego", ["Where in the World is Carmen San Diego"], fields: [{name: :word_end}]
-  end
-
-  def test_word_start_multiple_words
-    store_names ["Dark Grey", "Dark Blue"]
-    assert_search "dark grey", ["Dark Grey"], fields: [{name: :word_start}]
-  end
-
-  def test_word_start_exact
-    store_names ["Back Scratcher", "Backpack"]
-    assert_order "back", ["Back Scratcher", "Backpack"], fields: [{name: :word_start}]
-  end
-
-  def test_word_start_exact_martin
-    store_names ["Martina", "Martin"]
-    assert_order "martin", ["Martin", "Martina"], fields: [{name: :word_start}]
-  end
-
-  # TODO find a better place
-
-  def test_exact
-    store_names ["hi@example.org"]
-    assert_search "hi@example.org", ["hi@example.org"], fields: [{name: :exact}]
-  end
-end