searchkick 3.1.0 → 3.1.1

data/docs/Searchkick-3-Upgrade.md

@@ -1,57 +0,0 @@
-# Searchkick 3 Upgrade
-
-## Before You Upgrade
-
-Searchkick 3 no longer uses types, since they are deprecated in Elasticsearch 6.
-
-If you use inheritance, add to your parent model:
-
-```ruby
-class Animal < ApplicationRecord
-  searchkick inheritance: true
-end
-```
-
-And do a full reindex before upgrading.
-
-## Upgrading
-
-Update your Gemfile:
-
-```ruby
-gem 'searchkick', '~> 3'
-```
-
-And run:
-
-```sh
-bundle update searchkick
-```
-
-We recommend you don’t stem conversions anymore, so conversions for `pepper` don’t affect `peppers`, but if you want to keep the old behavior, use:
-
-```ruby
-Searchkick.model_options = {
-  stem_conversions: true
-}
-```
-
-Searchkick 3 disables the `_all` field by default, since Elasticsearch 6 removes the ability to reindex with it. If you’re on Elasticsearch 5 and still need it, add to your model:
-
-```ruby
-class Product < ApplicationRecord
-  searchkick _all: true
-end
-```
-
-If you use `record.reindex_async` or `record.reindex(async: true)`, replace it with:
-
-```ruby
-record.reindex(mode: :async)
-```
-
-If you use `log: true` with `boost_by`, replace it with `modifier: "ln2p"`.
-
-If you use the `body` option and have warnings about incompatible options, remove them, as they now throw an `ArgumentError`.
-
-Check out the [changelog](https://github.com/ankane/searchkick/blob/master/CHANGELOG.md) for the full list of changes.

data/searchkick.gemspec

@@ -1,30 +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.required_ruby_version = ">= 2.2.0"
-
-  spec.add_dependency "activemodel", ">= 4.2"
-  spec.add_dependency "elasticsearch", ">= 5"
-  spec.add_dependency "hashie"
-
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "minitest"
-  spec.add_development_dependency "rake"
-end

data/test/aggs_test.rb

@@ -1,217 +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
-
-  def test_body_options
-    products =
-      Product.search("*",
-        body_options: {
-          aggs: {
-            price: {
-              histogram: {field: :price, interval: 10}
-            }
-          }
-        }
-      )
-
-    expected = [
-      {"key" => 0.0, "doc_count" => 1},
-      {"key" => 10.0, "doc_count" => 1},
-      {"key" => 20.0, "doc_count" => 2}
-    ]
-    assert_equal products.aggs["price"]["buckets"], expected
-  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,81 +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
-
-  def test_exact_case
-    store_names ["Hello"]
-    assert_search "hello", [], fields: [{name: :exact}]
-    assert_search "Hello", ["Hello"], fields: [{name: :exact}]
-  end
-end

data/test/boost_test.rb

@@ -1,225 +0,0 @@
-require_relative "test_helper"
-
-class BoostTest < Minitest::Test
-  # conversions
-
-  def test_conversions
-    store [
-      {name: "Tomato A", conversions: {"tomato" => 1}},
-      {name: "Tomato B", conversions: {"tomato" => 2}},
-      {name: "Tomato C", conversions: {"tomato" => 3}}
-    ]
-    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"]
-    assert_equal_scores "tomato", conversions: false
-  end
-
-  def test_multiple_conversions
-    store [
-      {name: "Speaker A", conversions_a: {"speaker" => 1}, conversions_b: {"speaker" => 6}},
-      {name: "Speaker B", conversions_a: {"speaker" => 2}, conversions_b: {"speaker" => 5}},
-      {name: "Speaker C", conversions_a: {"speaker" => 3}, conversions_b: {"speaker" => 4}}
-    ], Speaker
-
-    assert_equal_scores "speaker", {conversions: false}, Speaker
-    assert_equal_scores "speaker", {}, Speaker
-    assert_equal_scores "speaker", {conversions: ["conversions_a", "conversions_b"]}, Speaker
-    assert_equal_scores "speaker", {conversions: ["conversions_b", "conversions_a"]}, Speaker
-    assert_order "speaker", ["Speaker C", "Speaker B", "Speaker A"], {conversions: "conversions_a"}, Speaker
-    assert_order "speaker", ["Speaker A", "Speaker B", "Speaker C"], {conversions: "conversions_b"}, Speaker
-  end
-
-  def test_multiple_conversions_with_boost_term
-    store [
-      {name: "Speaker A", conversions_a: {"speaker" => 4, "speaker_1" => 1}},
-      {name: "Speaker B", conversions_a: {"speaker" => 3, "speaker_1" => 2}},
-      {name: "Speaker C", conversions_a: {"speaker" => 2, "speaker_1" => 3}},
-      {name: "Speaker D", conversions_a: {"speaker" => 1, "speaker_1" => 4}}
-    ], Speaker
-
-    assert_order "speaker", ["Speaker A", "Speaker B", "Speaker C", "Speaker D"], {conversions: "conversions_a"}, Speaker
-    assert_order "speaker", ["Speaker D", "Speaker C", "Speaker B", "Speaker A"], {conversions: "conversions_a", conversions_term: "speaker_1"}, Speaker
-  end
-
-  def test_conversions_case
-    store [
-      {name: "Tomato A", conversions: {"tomato" => 1, "TOMATO" => 1, "tOmAtO" => 1}},
-      {name: "Tomato B", conversions: {"tomato" => 2}}
-    ]
-    assert_order "tomato", ["Tomato A", "Tomato B"]
-  end
-
-  # global boost
-
-  def test_boost
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", orders_count: 10},
-      {name: "Tomato C", orders_count: 100}
-    ]
-    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost: "orders_count"
-  end
-
-  def test_boost_zero
-    store [
-      {name: "Zero Boost", orders_count: 0}
-    ]
-    assert_order "zero", ["Zero Boost"], boost: "orders_count"
-  end
-
-  def test_conversions_weight
-    store [
-      {name: "Product Boost", orders_count: 20},
-      {name: "Product Conversions", conversions: {"product" => 10}}
-    ]
-    assert_order "product", ["Product Conversions", "Product Boost"], boost: "orders_count"
-  end
-
-  def test_boost_fields
-    store [
-      {name: "Red", color: "White"},
-      {name: "White", color: "Red Red Red"}
-    ]
-    assert_order "red", ["Red", "White"], fields: ["name^10", "color"]
-  end
-
-  def test_boost_fields_decimal
-    store [
-      {name: "Red", color: "White"},
-      {name: "White", color: "Red Red Red"}
-    ]
-    assert_order "red", ["Red", "White"], fields: ["name^10.5", "color"]
-  end
-
-  def test_boost_fields_word_start
-    store [
-      {name: "Red", color: "White"},
-      {name: "White", color: "Red Red Red"}
-    ]
-    assert_order "red", ["Red", "White"], fields: [{"name^10" => :word_start}, "color"]
-  end
-
-  # for issue #855
-  def test_apostrophes
-    store_names ["Valentine's Day Special"]
-    assert_search "Valentines", ["Valentine's Day Special"], fields: ["name^5"]
-    assert_search "Valentine's", ["Valentine's Day Special"], fields: ["name^5"]
-    assert_search "Valentine", ["Valentine's Day Special"], fields: ["name^5"]
-  end
-
-  def test_boost_by
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", orders_count: 10},
-      {name: "Tomato C", orders_count: 100}
-    ]
-    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: [:orders_count]
-    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: {orders_count: {factor: 10}}
-  end
-
-  def test_boost_by_missing
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", orders_count: 10},
-    ]
-
-    assert_order "tomato", ["Tomato A", "Tomato B"], boost_by: {orders_count: {missing: 100}}
-  end
-
-  def test_boost_by_boost_mode_multiply
-    store [
-      {name: "Tomato A", found_rate: 0.9},
-      {name: "Tomato B"},
-      {name: "Tomato C", found_rate: 0.5}
-    ]
-
-    assert_order "tomato", ["Tomato B", "Tomato A", "Tomato C"], boost_by: {found_rate: {boost_mode: "multiply"}}
-  end
-
-  def test_boost_where
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", user_ids: [1, 2]},
-      {name: "Tomato C", user_ids: [3]}
-    ]
-    assert_first "tomato", "Tomato B", boost_where: {user_ids: 2}
-    assert_first "tomato", "Tomato B", boost_where: {user_ids: 1..2}
-    assert_first "tomato", "Tomato B", boost_where: {user_ids: [1, 4]}
-    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: 2, factor: 10}}
-    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: [1, 4], factor: 10}}
-    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_where: {user_ids: [{value: 1, factor: 10}, {value: 3, factor: 20}]}
-  end
-
-  def test_boost_by_recency
-    store [
-      {name: "Article 1", created_at: 2.days.ago},
-      {name: "Article 2", created_at: 1.day.ago},
-      {name: "Article 3", created_at: Time.now}
-    ]
-    assert_order "article", ["Article 3", "Article 2", "Article 1"], boost_by_recency: {created_at: {scale: "7d", decay: 0.5}}
-  end
-
-  def test_boost_by_recency_origin
-    store [
-      {name: "Article 1", created_at: 2.days.ago},
-      {name: "Article 2", created_at: 1.day.ago},
-      {name: "Article 3", created_at: Time.now}
-    ]
-    assert_order "article", ["Article 1", "Article 2", "Article 3"], boost_by_recency: {created_at: {origin: 2.days.ago, scale: "7d", decay: 0.5}}
-  end
-
-  def test_boost_by_distance
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
-    ]
-    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: [37, -122], scale: "1000mi"}
-  end
-
-  def test_boost_by_distance_hash
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
-    ]
-    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: {lat: 37, lon: -122}, scale: "1000mi"}
-  end
-
-  def test_boost_by_distance_v2
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
-    ]
-    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {location: {origin: [37, -122], scale: "1000mi"}}
-  end
-
-  def test_boost_by_distance_v2_hash
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
-    ]
-    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {location: {origin: {lat: 37, lon: -122}, scale: "1000mi"}}
-  end
-
-  def test_boost_by_distance_v2_factor
-    store [
-      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167, found_rate: 0.1},
-      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000, found_rate: 0.99},
-      {name: "San Marino", latitude: 43.9333, longitude: 12.4667, found_rate: 0.2}
-    ]
-
-    assert_order "san", ["San Antonio","San Francisco", "San Marino"], boost_by: {found_rate: {factor: 100}}, boost_by_distance: {location: {origin: [37, -122], scale: "1000mi"}}
-    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by: {found_rate: {factor: 100}}, boost_by_distance: {location: {origin: [37, -122], scale: "1000mi", factor: 100}}
-  end
-
-  def test_boost_by_indices
-    skip if cequel?
-
-    store_names ["Rex"], Animal
-    store_names ["Rexx"], Product
-
-    assert_order "Rex", ["Rexx", "Rex"], {index_name: [Animal, Product], indices_boost: {Animal => 1, Product => 200}, fields: [:name]}, Store
-  end
-end