searchkick 1.5.1 → 2.0.0

data/lib/searchkick/results.rb

@@ -81,10 +81,6 @@ module Searchkick
       end
     end
 
-    def facets
-      response["facets"]
-    end
-
     def aggregations
       response["aggregations"]
     end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "1.5.1"
+  VERSION = "2.0.0"
 end

data/searchkick.gemspec

@@ -13,16 +13,16 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/ankane/searchkick"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  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)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activemodel"
+  spec.add_dependency "activemodel", ">= 4.1"
   spec.add_dependency "elasticsearch", ">= 1"
   spec.add_dependency "hashie"
 
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
 end

data/test/aggs_test.rb

@@ -42,7 +42,7 @@ class AggsTest < Minitest::Test
     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"]) unless Searchkick.server_below?("1.4.0")
+    assert_equal(1, agg["sum_other_doc_count"])
   end
 
   def test_ranges
@@ -110,11 +110,7 @@ class AggsTest < Minitest::Test
               }
     ).aggs
 
-    if elasticsearch_below20?
-      assert_equal 2, aggs["products_per_year"]["buckets"].size
-    else
-      assert_equal 4, aggs["products_per_year"]["buckets"].size
-    end
+    assert_equal 4, aggs["products_per_year"]["buckets"].size
   end
 
   protected

data/test/autocomplete_test.rb

@@ -3,17 +3,17 @@ require_relative "test_helper"
 class AutocompleteTest < Minitest::Test
   def test_autocomplete
     store_names ["Hummus"]
-    assert_search "hum", ["Hummus"], autocomplete: true
+    assert_search "hum", ["Hummus"], match: :text_start
   end
 
   def test_autocomplete_two_words
     store_names ["Organic Hummus"]
-    assert_search "hum", [], autocomplete: true
+    assert_search "hum", [], match: :text_start
   end
 
   def test_autocomplete_fields
     store_names ["Hummus"]
-    assert_search "hum", ["Hummus"], autocomplete: true, fields: [:name]
+    assert_search "hum", ["Hummus"], match: :text_start, fields: [:name]
   end
 
   def test_text_start

data/test/boost_test.rb

@@ -14,8 +14,6 @@ class BoostTest < Minitest::Test
   end
 
   def test_multiple_conversions
-    skip if elasticsearch_below14?
-
     store [
       {name: "Speaker A", conversions_a: {"speaker" => 1}, conversions_b: {"speaker" => 6}},
       {name: "Speaker B", conversions_a: {"speaker" => 2}, conversions_b: {"speaker" => 5}},
@@ -64,26 +62,6 @@ class BoostTest < Minitest::Test
     assert_order "product", ["Product Conversions", "Product Boost"], boost: "orders_count"
   end
 
-  def test_user_id
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", user_ids: [1, 2, 3]},
-      {name: "Tomato C"},
-      {name: "Tomato D"}
-    ]
-    assert_first "tomato", "Tomato B", user_id: 2
-  end
-
-  def test_personalize
-    store [
-      {name: "Tomato A"},
-      {name: "Tomato B", user_ids: [1, 2, 3]},
-      {name: "Tomato C"},
-      {name: "Tomato D"}
-    ]
-    assert_first "tomato", "Tomato B", personalize: {user_ids: 2}
-  end
-
   def test_boost_fields
     store [
       {name: "Red", color: "White"},

data/test/index_test.rb

@@ -12,7 +12,7 @@ class IndexTest < Minitest::Test
     old_index.create
     different_index.create
 
-    Product.clean_indices
+    Product.searchkick_index.clean_indices
 
     assert Product.searchkick_index.exists?
     assert different_index.exists?
@@ -23,7 +23,7 @@ class IndexTest < Minitest::Test
     old_index = Searchkick::Index.new("products_test_20130801000000")
     old_index.create
 
-    Product.clean_indices
+    Product.searchkick_index.clean_indices
 
     assert !old_index.exists?
   end
@@ -35,19 +35,13 @@ class IndexTest < Minitest::Test
 
   def test_mapping
     store_names ["Dollar Tree"], Store
-    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
-    assert_equal ["Dollar Tree"], Store.search(query: {match: {name: "Dollar Tree"}}).map(&:name)
-  end
-
-  def test_json
-    store_names ["Dollar Tree"], Store
-    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
-    assert_equal ["Dollar Tree"], Store.search(json: {query: {match: {name: "Dollar Tree"}}}, load: false).map(&:name)
+    assert_equal [], Store.search(body: {query: {match: {name: "dollar"}}}).map(&:name)
+    assert_equal ["Dollar Tree"], Store.search(body: {query: {match: {name: "Dollar Tree"}}}).map(&:name)
   end
 
   def test_body
     store_names ["Dollar Tree"], Store
-    assert_equal [], Store.search(query: {match: {name: "dollar"}}).map(&:name)
+    assert_equal [], Store.search(body: {query: {match: {name: "dollar"}}}).map(&:name)
     assert_equal ["Dollar Tree"], Store.search(body: {query: {match: {name: "Dollar Tree"}}}, load: false).map(&:name)
   end
 
@@ -61,7 +55,7 @@ class IndexTest < Minitest::Test
   end
 
   def test_tokens
-    assert_equal ["dollar", "dollartre", "tree"], Product.searchkick_index.tokens("Dollar Tree")
+    assert_equal ["dollar", "dollartre", "tree"], Product.searchkick_index.tokens("Dollar Tree", analyzer: "searchkick_index")
   end
 
   def test_tokens_analyzer

data/test/inheritance_test.rb

@@ -40,13 +40,13 @@ class InheritanceTest < Minitest::Test
   def test_child_autocomplete
     store_names ["Max"], Cat
     store_names ["Mark"], Dog
-    assert_equal ["Max"], Cat.search("ma", fields: [:name], autocomplete: true).map(&:name)
+    assert_equal ["Max"], Cat.search("ma", fields: [:name], match: :text_start).map(&:name)
   end
 
   def test_parent_autocomplete
     store_names ["Max"], Cat
     store_names ["Bear"], Dog
-    assert_equal ["Bear"], Animal.search("bea", fields: [:name], autocomplete: true).map(&:name).sort
+    assert_equal ["Bear"], Animal.search("bea", fields: [:name], match: :text_start).map(&:name).sort
   end
 
   # def test_child_suggest

data/test/match_test.rb

@@ -112,14 +112,12 @@ class MatchTest < Minitest::Test
   end
 
   def test_misspelling_zucchini_transposition
-    skip if elasticsearch_below14?
     store_names ["zucchini"]
     assert_search "zuccihni", ["zucchini"]
     assert_search "zuccihni", [], misspellings: {transpositions: false}
   end
 
   def test_misspelling_lasagna
-    skip if elasticsearch_below14?
     store_names ["lasagna"]
     assert_search "lasanga", ["lasagna"], misspellings: {transpositions: true}
     assert_search "lasgana", ["lasagna"], misspellings: {transpositions: true}
@@ -128,7 +126,6 @@ class MatchTest < Minitest::Test
   end
 
   def test_misspelling_lasagna_pasta
-    skip if elasticsearch_below14?
     store_names ["lasagna pasta"]
     assert_search "lasanga", ["lasagna pasta"], misspellings: {transpositions: true}
     assert_search "lasanga pasta", ["lasagna pasta"], misspellings: {transpositions: true}

data/test/query_test.rb

@@ -12,9 +12,8 @@ class QueryTest < Minitest::Test
   end
 
   def test_with_effective_min_score
-    min_score = elasticsearch_below50? ? 0.1 : 1
     store_names ["Milk", "Milk2"]
-    assert_search "milk", ["Milk"], body_options: {min_score: min_score}
+    assert_search "milk", ["Milk"], body_options: {min_score: 1}
   end
 
   def test_with_uneffective_min_score

data/test/reindex_test.rb

@@ -0,0 +1,25 @@
+require_relative "test_helper"
+
+class ReindexTest < Minitest::Test
+  def setup
+    skip if nobrainer?
+    super
+  end
+
+  def test_scoped
+    store_names ["Product A"]
+    Searchkick.callbacks(false) do
+      store_names ["Product B", "Product C"]
+    end
+    Product.where(name: "Product B").reindex(refresh: true)
+    assert_search "product", ["Product A", "Product B"]
+  end
+
+  def test_associations
+    store_names ["Product A"]
+    store = Store.create!(name: "Test")
+    Product.create!(name: "Product B", store_id: store.id)
+    store.products.reindex(refresh: true)
+    assert_search "product", ["Product A", "Product B"]
+  end
+end

data/test/sql_test.rb

@@ -1,12 +1,6 @@
 require_relative "test_helper"
 
 class SqlTest < Minitest::Test
-  def test_partial
-    store_names ["Honey"]
-    assert_search "fresh honey", []
-    assert_search "fresh honey", ["Honey"], partial: true
-  end
-
   def test_operator
     store_names ["Honey"]
     assert_search "fresh honey", []
@@ -90,32 +84,28 @@ class SqlTest < Minitest::Test
   # select
 
   def test_select
-    skip unless elasticsearch_below50?
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false, select: [:name, :store_id]).first
     assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal ["Product A"], result.name # this is not great
-    assert_equal [1], result.store_id
+    assert_equal "Product A", result.name
+    assert_equal 1, result.store_id
   end
 
   def test_select_array
-    skip unless elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2]}]
     result = Product.search("product", load: false, select: [:user_ids]).first
     assert_equal [1, 2], result.user_ids
   end
 
   def test_select_single_field
-    skip unless elasticsearch_below50?
     store [{name: "Product A", store_id: 1}]
     result = Product.search("product", load: false, select: :name).first
     assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal ["Product A"], result.name
+    assert_equal "Product A", result.name
     assert_nil result.store_id
   end
 
   def test_select_all
-    skip unless elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2]}]
     hit = Product.search("product", select: true).hits.first
     assert_equal hit["_source"]["name"], "Product A"
@@ -123,102 +113,64 @@ class SqlTest < Minitest::Test
   end
 
   def test_select_none
-    skip unless elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2]}]
     hit = Product.search("product", select: []).hits.first
     assert_nil hit["_source"]
-  end
-
-  # select_v2
-
-  def test_select_v2
-    store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", load: false, select_v2: [:name, :store_id]).first
-    assert_equal %w(id name store_id), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_equal 1, result.store_id
-  end
-
-  def test_select_v2_array
-    store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select_v2: [:user_ids]).first
-    assert_equal [1, 2], result.user_ids
-  end
-
-  def test_select_v2_single_field
-    store [{name: "Product A", store_id: 1}]
-    result = Product.search("product", load: false, select_v2: :name).first
-    assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
-    assert_equal "Product A", result.name
-    assert_nil result.store_id
-  end
-
-  def test_select_v2_all
-    store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", select_v2: true).hits.first
-    assert_equal hit["_source"]["name"], "Product A"
-    assert_equal hit["_source"]["user_ids"], [1, 2]
-  end
-
-  def test_select_v2_none
-    store [{name: "Product A", user_ids: [1, 2]}]
-    hit = Product.search("product", select_v2: []).hits.first
-    assert_nil hit["_source"]
-    hit = Product.search("product", select_v2: false).hits.first
+    hit = Product.search("product", select: false).hits.first
     assert_nil hit["_source"]
   end
 
-  def test_select_v2_include
+  def test_select_include
     skip unless elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select_v2: {include: [:name]}).first
+    result = Product.search("product", load: false, select: {include: [:name]}).first
     assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_nil result.store_id
   end
 
-  def test_select_v2_exclude
+  def test_select_exclude
     skip unless elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select_v2: {exclude: [:name]}).first
+    result = Product.search("product", load: false, select: {exclude: [:name]}).first
     assert_nil result.name
     assert_equal [1, 2], result.user_ids
     assert_equal 1, result.store_id
   end
 
-  def test_select_v2_include_and_exclude
+  def test_select_include_and_exclude
     skip unless elasticsearch_below50?
     # let's take this to the next level
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select_v2: {include: [:store_id], exclude: [:name]}).first
+    result = Product.search("product", load: false, select: {include: [:store_id], exclude: [:name]}).first
     assert_equal 1, result.store_id
     assert_nil result.name
     assert_nil result.user_ids
   end
 
-  def test_select_v2_includes
+  def test_select_includes
     skip if elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2]}]
-    result = Product.search("product", load: false, select_v2: {includes: [:name]}).first
+    result = Product.search("product", load: false, select: {includes: [:name]}).first
     assert_equal %w(id name), result.keys.reject { |k| k.start_with?("_") }.sort
     assert_equal "Product A", result.name
     assert_nil result.store_id
   end
 
-  def test_select_v2_excludes
+  def test_select_excludes
     skip if elasticsearch_below50?
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select_v2: {excludes: [:name]}).first
+    result = Product.search("product", load: false, select: {excludes: [:name]}).first
     assert_nil result.name
     assert_equal [1, 2], result.user_ids
     assert_equal 1, result.store_id
   end
 
-  def test_select_v2_include_and_excludes
+  def test_select_include_and_excludes
     skip if elasticsearch_below50?
     # let's take this to the next level
     store [{name: "Product A", user_ids: [1, 2], store_id: 1}]
-    result = Product.search("product", load: false, select_v2: {includes: [:store_id], excludes: [:name]}).first
+    result = Product.search("product", load: false, select: {includes: [:store_id], excludes: [:name]}).first
     assert_equal 1, result.store_id
     assert_nil result.name
     assert_nil result.user_ids

data/test/test_helper.rb

@@ -29,47 +29,16 @@ def elasticsearch_below22?
   Searchkick.server_below?("2.2.0")
 end
 
-def elasticsearch_below20?
-  Searchkick.server_below?("2.0.0")
-end
-
-def elasticsearch_below14?
-  Searchkick.server_below?("1.4.0")
-end
-
-def mongoid2?
-  defined?(Mongoid) && Mongoid::VERSION.starts_with?("2.")
-end
-
 def nobrainer?
   defined?(NoBrainer)
 end
 
-def activerecord_below41?
-  defined?(ActiveRecord) && Gem::Version.new(ActiveRecord::VERSION::STRING) < Gem::Version.new("4.1.0")
-end
-
 if defined?(Mongoid)
   Mongoid.logger.level = Logger::INFO
   Mongo::Logger.logger.level = Logger::INFO if defined?(Mongo::Logger)
 
-  if mongoid2?
-    # enable comparison of BSON::ObjectIds
-    module BSON
-      class ObjectId
-        def <=>(other)
-          data <=> other.data
-        end
-      end
-    end
-  end
-
   Mongoid.configure do |config|
-    if mongoid2?
-      config.master = Mongo::Connection.new.db("searchkick_test")
-    else
-      config.connect_to "searchkick_test"
-    end
+    config.connect_to "searchkick_test"
   end
 
   class Product
@@ -303,10 +272,8 @@ class Product
       "lightbulb => led,lightbulb",
       "lightbulb => halogenlamp"
     ],
-    autocomplete: [:name],
     suggest: [:name, :color],
     conversions: [:conversions],
-    personalize: :user_ids,
     locations: [:location, :multiple_locations],
     text_start: [:name],
     text_middle: [:name],
@@ -316,10 +283,8 @@ class Product
     word_end: [:name],
     highlight: [:name],
     searchable: [:name, :color],
-    default_fields: [:name, :color],
     filterable: [:name, :color, :description],
-    # unsearchable: [:description],
-    # only_analyzed: [:alt_description],
+    similarity: "BM25",
     match: ENV["MATCH"] ? ENV["MATCH"].to_sym : nil
 
   attr_accessor :conversions, :user_ids, :aisle, :details
@@ -401,7 +366,7 @@ end
 
 class Animal
   searchkick \
-    autocomplete: [:name],
+    text_start: [:name],
     suggest: [:name],
     index_name: -> { "#{name.tableize}-#{Date.today.year}" }
     # wordnet: true