searchkick 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 95d822316595ca2806bc9f2e3e44644ee2ab5fd8
-  data.tar.gz: 27f86dc98a28378ee489b5adf7bfd11be054baf1
+  metadata.gz: 5fcfaef2d99cf6def7035bc882eecf161f687dca
+  data.tar.gz: a50200b8381e063e3c355586c898d1d8dc3b360a
 SHA512:
-  metadata.gz: fb18990e391306eb6d3f9a6193b8c14acf8cb22691f0a470d7c47b40c6146a58bc7babc6250378dfadf86b85f5f6846bd79f5302969b54de632df77aa7a55809
-  data.tar.gz: 0983c46e8eda2d402cc632a9849e97fca61f3036cfa96378ff81921dc6901416671b6192a184a23dc04615534422f79a7f00c2694c3b9cb46d7b38f7a2410345
+  metadata.gz: 6ddbce0ef6d29c51b2884ffc1791acedb886a3a4915889b059941fdcf0c9a5f9cbe68e50df7a82934d9cbc8b278b032bd789a2ec57d354f7b2fc09ebe9a91f8b
+  data.tar.gz: ab3dbbb296596682c5b9caaf6ba47f5d5299e60fd66bc53f31d14ecd9ac99f3f2f96404ea5f71e36f4cf02e310ffabb8c0d5c1b9a155d05e474e1e03bae67764

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 2.1.1
+
+- Fixed duplicate notifications
+- Added support for `connection_pool`
+- Added `exclude` option
+
 ## 2.1.0
 
 - Background reindexing and queues are officially supported

data/Gemfile

@@ -9,3 +9,4 @@ gem "gemoji-parser"
 gem "typhoeus"
 gem "activejob"
 gem "redis"
+gem "connection_pool"

data/README.md

@@ -34,6 +34,7 @@ Plus:
 - [Getting Started](#getting-started)
 - [Querying](#querying)
 - [Indexing](#indexing)
+- [Instant Search / Autocomplete](#instant-search--autocomplete)
 - [Aggregations](#aggregations)
 - [Deployment](#deployment)
 - [Performance](#performance)
@@ -376,6 +377,14 @@ Turn off misspellings with:
 Product.search "zuchini", misspellings: false # no zucchini
 ```
 
+### Bad Matches
+
+If a user searches `butter`, they may also get results for `peanut butter`. To prevent this, use:
+
+```ruby
+Product.search "butter", exclude: ["peanut butter"]
+```
+
 ### Emoji
 
 Search :ice_cream::cake: and get `ice cream cake`!
@@ -528,6 +537,11 @@ Product.search "apple", track: {user_id: current_user.id}
 
 [See the docs](https://github.com/ankane/searchjoy) for how to install and use.
 
+Focus on:
+
+- top searches with low conversions
+- top searches with no results
+
 ### Keep Getting Better
 
 Searchkick can use conversion data to learn what users are looking for. If a user searches for “ice cream” and adds Ben & Jerry’s Chunky Monkey to the cart (our conversion metric at Instacart), that item gets a little more weight for similar searches.
@@ -589,20 +603,22 @@ Autocomplete predicts what a user will type, making the search experience faster
 
 ![Autocomplete](https://raw.githubusercontent.com/ankane/searchkick/gh-pages/autocomplete.png)
 
-**Note:** If you only have a few thousand records, don’t use Searchkick for autocomplete. It’s *much* faster to load all records into JavaScript and autocomplete there (eliminates network requests).
+**Note:** To autocomplete on general categories (like `cereal` rather than product names), check out [Autosuggest](https://github.com/ankane/autosuggest).
+
+**Note 2:** If you only have a few thousand records, don’t use Searchkick for autocomplete. It’s *much* faster to load all records into JavaScript and autocomplete there (eliminates network requests).
 
 First, specify which fields use this feature. This is necessary since autocomplete can increase the index size significantly, but don’t worry - this gives you blazing faster queries.
 
 ```ruby
-class Book < ActiveRecord::Base
-  searchkick word_start: [:title, :author]
+class Movie < ActiveRecord::Base
+  searchkick word_start: [:title, :director]
 end
 ```
 
 Reindex and search with:
 
 ```ruby
-Book.search "tipping poi", match: :word_start
+Movie.search "jurassic pa", match: :word_start
 ```
 
 Typically, you want to use a JavaScript library like [typeahead.js](http://twitter.github.io/typeahead.js/) or [jQuery UI](http://jqueryui.com/autocomplete/).
@@ -612,11 +628,10 @@ Typically, you want to use a JavaScript library like [typeahead.js](http://twitt
 First, add a route and controller action.
 
 ```ruby
-# app/controllers/books_controller.rb
-class BooksController < ApplicationController
+class MoviesController < ApplicationController
   def autocomplete
-    render json: Book.search(params[:query], {
-      fields: ["title^5", "author"],
+    render json: Movie.search(params[:query], {
+      fields: ["title^5", "director"],
       match: :word_start,
       limit: 10,
       load: false,
@@ -626,6 +641,8 @@ class BooksController < ApplicationController
 end
 ```
 
+**Note:** Use `load: false` and `misspellings: {below: n}` (or `misspellings: false`) for best performance.
+
 Then add the search box and JavaScript code to a view.
 
 ```html
@@ -634,16 +651,16 @@ Then add the search box and JavaScript code to a view.
 <script src="jquery.js"></script>
 <script src="typeahead.bundle.js"></script>
 <script>
-  var books = new Bloodhound({
+  var movies = new Bloodhound({
     datumTokenizer: Bloodhound.tokenizers.whitespace,
     queryTokenizer: Bloodhound.tokenizers.whitespace,
     remote: {
-      url: '/books/autocomplete?query=%QUERY',
+      url: '/movies/autocomplete?query=%QUERY',
       wildcard: '%QUERY'
     }
   });
   $('#query').typeahead(null, {
-    source: books
+    source: movies
   });
 </script>
 ```
@@ -844,7 +861,7 @@ product.similar(fields: [:name], where: {size: "12 oz"})
 ### Geospatial Searches
 
 ```ruby
-class City < ActiveRecord::Base
+class Restaurant < ActiveRecord::Base
   searchkick locations: [:location]
 
   def search_data
@@ -856,19 +873,19 @@ end
 Reindex and search with:
 
 ```ruby
-City.search "san", where: {location: {near: {lat: 37, lon: -114}, within: "100mi"}} # or 160km
+Restaurant.search "pizza", where: {location: {near: {lat: 37, lon: -114}, within: "100mi"}} # or 160km
 ```
 
 Bounded by a box
 
 ```ruby
-City.search "san", where: {location: {top_left: {lat: 38, lon: -123}, bottom_right: {lat: 37, lon: -122}}}
+Restaurant.search "sushi", where: {location: {top_left: {lat: 38, lon: -123}, bottom_right: {lat: 37, lon: -122}}}
 ```
 
 Bounded by a polygon
 
 ```ruby
-City.search "san", where: {location: {geo_polygon: {points: [{lat: 38, lon: -123}, {lat: 39, lon: -123}, {lat: 37, lon: 122}]}}}
+Restaurant.search "dessert", where: {location: {geo_polygon: {points: [{lat: 38, lon: -123}, {lat: 39, lon: -123}, {lat: 37, lon: 122}]}}}
 ```
 
 ### Boost By Distance
@@ -876,13 +893,13 @@ City.search "san", where: {location: {geo_polygon: {points: [{lat: 38, lon: -123
 Boost results by distance - closer results are boosted more
 
 ```ruby
-City.search "san", boost_by_distance: {location: {origin: {lat: 37, lon: -122}}}
+Restaurant.search "noodles", boost_by_distance: {location: {origin: {lat: 37, lon: -122}}}
 ```
 
 Also supports [additional options](https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-function-score-query.html#_decay_functions)
 
 ```ruby
-City.search "san", boost_by_distance: {location: {origin: {lat: 37, lon: -122}, function: "linear", scale: "30mi", decay: 0.5}}
+Restaurant.search "wings", boost_by_distance: {location: {origin: {lat: 37, lon: -122}, function: "linear", scale: "30mi", decay: 0.5}}
 ```
 
 ### Geo Shapes
@@ -890,7 +907,7 @@ City.search "san", boost_by_distance: {location: {origin: {lat: 37, lon: -122},
 You can also index and search geo shapes.
 
 ```ruby
-class City < ActiveRecord::Base
+class Restaurant < ActiveRecord::Base
   searchkick geo_shape: {
     bounds: {tree: "geohash", precision: "1km"}
   }
@@ -911,25 +928,25 @@ See the [Elasticsearch documentation](https://www.elastic.co/guide/en/elasticsea
 Find shapes intersecting with the query shape
 
 ```ruby
-City.search "san", where: {bounds: {geo_shape: {type: "polygon", coordinates: [[{lat: 38, lon: -123}, ...]]}}}
+Restaurant.search "soup", where: {bounds: {geo_shape: {type: "polygon", coordinates: [[{lat: 38, lon: -123}, ...]]}}}
 ```
 
 Falling entirely within the query shape
 
 ```ruby
-City.search "san", where: {bounds: {geo_shape: {type: "circle", relation: "within", coordinates: [{lat: 38, lon: -123}], radius: "1km"}}}
+Restaurant.search "salad", where: {bounds: {geo_shape: {type: "circle", relation: "within", coordinates: [{lat: 38, lon: -123}], radius: "1km"}}}
 ```
 
 Not touching the query shape
 
 ```ruby
-City.search "san", where: {bounds: {geo_shape: {type: "envelope", relation: "disjoint", coordinates: [{lat: 38, lon: -123}, {lat: 37, lon: -122}]}}}
+Restaurant.search "burger", where: {bounds: {geo_shape: {type: "envelope", relation: "disjoint", coordinates: [{lat: 38, lon: -123}, {lat: 37, lon: -122}]}}}
 ```
 
 Containing the query shape (Elasticsearch 2.2+)
 
 ```ruby
-City.search "san", where: {bounds: {geo_shape: {type: "envelope", relation: "contains", coordinates: [{lat: 38, lon: -123}, {lat: 37, lon: -122}]}}}
+Restaurant.search "fries", where: {bounds: {geo_shape: {type: "envelope", relation: "contains", coordinates: [{lat: 38, lon: -123}, {lat: 37, lon: -122}]}}}
 ```
 
 ## Inheritance
@@ -1137,7 +1154,7 @@ If you run into issues on Windows, check out [this post](https://www.rastating.c
 
 ### Searchable Fields
 
-By default, all string fields are searchable. Speed up indexing and reduce index size by only making some fields searchable.
+By default, all string fields are searchable (can be used in `fields` option). Speed up indexing and reduce index size by only making some fields searchable. This disables the `_all` field unless it’s listed.
 
 ```ruby
 class Product < ActiveRecord::Base
@@ -1182,12 +1199,45 @@ And use:
 Searchkick.reindex_status(index_name)
 ```
 
+You can use [ActiveJob::TrafficControl](https://github.com/nickelser/activejob-traffic_control) to control concurrency. Install the gem and create an initializer with:
+
+```ruby
+require "active_job/traffic_control"
+
+Searchkick.redis = Redis.new
+ActiveJob::TrafficControl.client = Searchkick.redis
+
+class Searchkick::BulkReindexJob
+  include ActiveJob::TrafficControl::Concurrency
+
+  concurrency 3, drop: false
+end
+```
+
+This will allow only 3 jobs to run at once.
+
+### Refresh Interval
+
+You can specify a longer refresh interval while reindexing to increase performance.
+
+```ruby
+Product.reindex(async: true, refresh_interval: "30s")
+```
+
+**Note:** This only makes a noticable difference with parallel reindexing.
+
+When promoting, have it restored to the value in your mapping (defaults to `1s`).
+
+```ruby
+Product.search_index.promote(index_name, update_refresh_interval: true)
+```
+
 ### Queuing
 
-Push ids of records needing reindexed to a queue and reindex in bulk for better performance. First, set up Redis in an initializer.
+Push ids of records needing reindexed to a queue and reindex in bulk for better performance. First, set up Redis in an initializer. We recommend using [connection_pool](https://github.com/mperham/connection_pool).
 
 ```ruby
-Searchkick.redis = Redis.new
+Searchkick.redis = ConnectionPool.new { Redis.new }
 ```
 
 And ask your models to queue updates.
@@ -1291,12 +1341,13 @@ class ReindexConversionsJob < ActiveJob::Base
 
     # split into groups
     recently_converted_ids.in_groups_of(1000, false) do |ids|
-      # fetch conversions and group by record
-      conversions_by_record = {}
+      # fetch conversions
       conversions =
         Searchjoy::Search.where(convertable_id: ids, convertable_type: class_name)
         .group(:convertable_id, :query).uniq.count(:user_id)
 
+      # group conversions by record
+      conversions_by_record = {}
       conversions.each do |(id, query), count|
         (conversions_by_record[id] ||= {})[query] = count
       end
@@ -1379,6 +1430,14 @@ products =
   end
 ```
 
+### Elasticsearch Gem
+
+Searchkick is built on top of the [elasticsearch](https://github.com/elastic/elasticsearch-ruby) gem. To access the client directly, use:
+
+```ruby
+Searchkick.client
+```
+
 ## Multi Search
 
 To batch search requests for performance, use:
@@ -1415,6 +1474,20 @@ To query nested data, use dot notation.
 User.search "san", fields: ["address.city"], where: {"address.zip_code" => 12345}
 ```
 
+## Search Concepts
+
+### Precision and Recall
+
+[Precision and recall](https://en.wikipedia.org/wiki/Precision_and_recall) are two key concepts in search (also known as *information retrieval*). To help illustrate, let’s walk through an example.
+
+You have a store with 16 types of apples. A user searches for `apples` gets 10 results. 8 of the results are for apples, and 2 are for apple juice.
+
+**Precision** is the fraction of documents in the results that are relevant. There are 10 results and 8 are relevant, so precision is 80%.
+
+**Recall** is the fraction of relevant documents in the results out of all relevant documents. There are 16 apples and only 8 in the results, so recall is 50%.
+
+There’s typically a trade-off between the two. As you tweak your search to increase precision (not return irrelevant documents), there’s are greater chance a relevant document also isn’t returned, which decreases recall. The opposite also applies. As you try to increase recall (return a higher number of relevent documents), there’s a greater chance you also return an irrelevant document, decreasing precision.
+
 ## Reference
 
 Reindex one record
@@ -1575,15 +1648,12 @@ Product.search("carrots", request_params: {search_type: "dfs_query_then_fetch"})
 
 Reindex conditionally
 
-**Note:** With ActiveRecord, use this feature with caution - [transaction rollbacks can cause data inconsistencies](https://github.com/elasticsearch/elasticsearch-rails/blob/master/elasticsearch-model/README.md#custom-callbacks)
-
 ```ruby
 class Product < ActiveRecord::Base
   searchkick callbacks: false
 
   # add the callbacks manually
-  after_save :reindex, if: -> (model) { model.name_changed? } # use your own condition
-  after_destroy :reindex
+  after_commit :reindex, if: -> (model) { model.previous_changes.key?("name") } # use your own condition
 end
 ```
 
@@ -1702,13 +1772,8 @@ Thanks to Karel Minarik for [Elasticsearch Ruby](https://github.com/elasticsearc
 
 ## Roadmap
 
-- More features for large data sets
-- Improve section on testing
-- Semantic search features
-- Search multiple fields for different terms
-- Search across models
-- Search nested objects
-- Much finer customization
+- Reindex API
+- Incorporate human eval
 
 ## Contributing
 

data/lib/searchkick/index.rb

@@ -66,26 +66,31 @@ module Searchkick
     alias_method :swap, :promote
 
     # record based
+    # use helpers for notifications
 
     def store(record)
-      bulk_index([record])
+      bulk_index_helper([record])
     end
 
     def remove(record)
-      bulk_delete([record])
+      bulk_delete_helper([record])
+    end
+
+    def update_record(record, method_name)
+      bulk_update_helper([record], method_name)
     end
 
     def bulk_delete(records)
-      Searchkick.indexer.queue(records.reject { |r| r.id.blank? }.map { |r| {delete: record_data(r)} })
+      bulk_delete_helper(records)
     end
 
     def bulk_index(records)
-      Searchkick.indexer.queue(records.map { |r| {index: record_data(r).merge(data: search_data(r))} })
+      bulk_index_helper(records)
     end
     alias_method :import, :bulk_index
 
     def bulk_update(records, method_name)
-      Searchkick.indexer.queue(records.map { |r| {update: record_data(r).merge(data: {doc: search_data(r, method_name)})} })
+      bulk_update_helper(records, method_name)
     end
 
     def record_data(r)
@@ -253,7 +258,7 @@ module Searchkick
 
       if batch
         import_or_update scope.to_a, method_name, async
-        redis.srem(batches_key, batch_id) if batch_id && redis
+        Searchkick.with_redis { |r| r.srem(batches_key, batch_id) } if batch_id
       elsif full && async
         full_reindex_async(scope)
       elsif scope.respond_to?(:find_in_batches)
@@ -278,7 +283,7 @@ module Searchkick
     end
 
     def batches_left
-      redis.scard(batches_key) if redis
+      Searchkick.with_redis { |r| r.scard(batches_key) }
     end
 
     # other
@@ -454,7 +459,7 @@ module Searchkick
         index_name: name,
         batch_id: batch_id
       }.merge(options))
-      redis.sadd(batches_key, batch_id) if redis
+      Searchkick.with_redis { |r| r.sadd(batches_key, batch_id) }
     end
 
     def batch_size
@@ -475,8 +480,16 @@ module Searchkick
       end
     end
 
-    def redis
-      Searchkick.redis
+    def bulk_index_helper(records)
+      Searchkick.indexer.queue(records.map { |r| {index: record_data(r).merge(data: search_data(r))} })
+    end
+
+    def bulk_delete_helper(records)
+      Searchkick.indexer.queue(records.reject { |r| r.id.blank? }.map { |r| {delete: record_data(r)} })
+    end
+
+    def bulk_update_helper(records, method_name)
+      Searchkick.indexer.queue(records.map { |r| {update: record_data(r).merge(data: {doc: search_data(r, method_name)})} })
     end
 
     def batches_key

data/lib/searchkick/logging.rb

@@ -45,12 +45,27 @@ module Searchkick
       end
     end
 
-    def import(records)
+    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
@@ -60,6 +75,7 @@ module Searchkick
         end
       end
     end
+    alias_method :import, :bulk_index
 
     def bulk_update(records, *args)
       if records.any?
@@ -67,6 +83,7 @@ module Searchkick
           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
@@ -83,6 +100,7 @@ module Searchkick
           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

data/lib/searchkick/model.rb

@@ -120,7 +120,7 @@ module Searchkick
             end
           else
             if method_name
-              self.class.searchkick_index.bulk_update([self], method_name)
+              self.class.searchkick_index.update_record(self, method_name)
             else
               self.class.searchkick_index.reindex_record(self)
             end

data/lib/searchkick/query.rb

@@ -14,7 +14,7 @@ module Searchkick
 
     def initialize(klass, term = "*", **options)
       unknown_keywords = options.keys - [:aggs, :body, :body_options, :boost,
-        :boost_by, :boost_by_distance, :boost_where, :conversions, :debug, :emoji, :execute, :explain,
+        :boost_by, :boost_by_distance, :boost_where, :conversions, :debug, :emoji, :exclude, :execute, :explain,
         :fields, :highlight, :includes, :index_name, :indices_boost, :limit, :load,
         :match, :misspellings, :offset, :operator, :order, :padding, :page, :per_page, :profile,
         :request_params, :routing, :select, :similar, :smart_aggs, :suggest, :track, :type, :where]
@@ -264,6 +264,7 @@ module Searchkick
           end
 
           fields.each do |field|
+            queries_to_add = []
             qs = []
 
             factor = boost_fields[field] || 1
@@ -290,7 +291,7 @@ module Searchkick
               ]
             elsif field.end_with?(".exact")
               f = field.split(".")[0..-2].join(".")
-              queries << {match: {f => shared_options.merge(analyzer: "keyword")}}
+              queries_to_add << {match: {f => shared_options.merge(analyzer: "keyword")}}
             else
               analyzer = field =~ /\.word_(start|middle|end)\z/ ? "searchkick_word_search" : "searchkick_autocomplete_search"
               qs << shared_options.merge(analyzer: analyzer)
@@ -300,21 +301,43 @@ module Searchkick
               qs.concat qs.map { |q| q.except(:cutoff_frequency).merge(fuzziness: edit_distance, prefix_length: prefix_length, max_expansions: max_expansions, boost: factor).merge(transpositions) }
             end
 
+            q2 = qs.map { |q| {match_type => {field => q}} }
+
             # boost exact matches more
             if field =~ /\.word_(start|middle|end)\z/ && searchkick_options[:word] != false
-              queries << {
+              queries_to_add << {
                 bool: {
                   must: {
                     bool: {
-                      should: qs.map { |q| {match_type => {field => q}} }
+                      should: q2
                     }
                   },
                   should: {match_type => {field.sub(/\.word_(start|middle|end)\z/, ".analyzed") => qs.first}}
                 }
               }
             else
-              queries.concat(qs.map { |q| {match_type => {field => q}} })
+              queries_to_add.concat(q2)
+            end
+
+            if options[:exclude]
+              must_not =
+                options[:exclude].map do |phrase|
+                  {
+                    match_phrase: {
+                      field => phrase
+                    }
+                  }
+                end
+
+              queries_to_add = [{
+                bool: {
+                  should: queries_to_add,
+                  must_not: must_not
+                }
+              }]
             end
+
+            queries.concat(queries_to_add)
           end
 
           payload = {

data/lib/searchkick/reindex_queue.rb

@@ -5,36 +5,32 @@ module Searchkick
     def initialize(name)
       @name = name
 
-      raise Searchkick::Error, "Searchkick.redis not set" unless redis
+      raise Searchkick::Error, "Searchkick.redis not set" unless Searchkick.redis
     end
 
     def push(record_id)
-      redis.lpush(redis_key, 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 = redis.rpop(redis_key)
+      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
-      redis.del(redis_key)
+      Searchkick.with_redis { |r| r.del(redis_key) }
     end
 
     def length
-      redis.llen(redis_key)
+      Searchkick.with_redis { |r| r.llen(redis_key) }
     end
 
     private
 
-    def redis
-      Searchkick.redis
-    end
-
     def redis_key
       "searchkick:reindex_queue:#{name}"
     end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "2.1.0"
+  VERSION = "2.1.1"
 end

data/lib/searchkick.rb

@@ -145,6 +145,18 @@ module Searchkick
     end
   end
 
+  def self.with_redis
+    if redis
+      if redis.respond_to?(:with)
+        redis.with do |r|
+          yield r
+        end
+      else
+        yield redis
+      end
+    end
+  end
+
   # private
   def self.load_records(records, ids)
     records =

data/test/match_test.rb

@@ -159,6 +159,25 @@ class MatchTest < Minitest::Test
     assert_search "almondmilks", ["Almond Milk"]
   end
 
+  # butter
+
+  def test_butter
+    store_names ["Butter Tub", "Peanut Butter Tub"]
+    assert_search "butter", ["Butter Tub"], exclude: ["peanut butter"]
+  end
+
+  def test_butter_word_start
+    store_names ["Butter Tub", "Peanut Butter Tub"]
+    assert_search "butter", ["Butter Tub"], exclude: ["peanut butter"], match: :word_start
+  end
+
+  def test_butter_exact
+    store_names ["Butter Tub", "Peanut Butter Tub"]
+    assert_search "butter", [], exclude: ["peanut butter"], match: :exact
+  end
+
+  # other
+
   def test_all
     store_names ["Product A", "Product B"]
     assert_search "*", ["Product A", "Product B"]

data/test/order_test.rb

@@ -29,12 +29,12 @@ class OrderTest < Minitest::Test
 
   def test_order_ignore_unmapped
     skip unless elasticsearch_below50?
-    assert_order "product", [], order: {not_mapped: {ignore_unmapped: true}}
+    assert_order "product", [], order: {not_mapped: {ignore_unmapped: true}}, conversions: false
   end
 
   def test_order_unmapped_type
     skip if elasticsearch_below50?
-    assert_order "product", [], order: {not_mapped: {unmapped_type: "long"}}
+    assert_order "product", [], order: {not_mapped: {unmapped_type: "long"}}, conversions: false
   end
 
   def test_order_array

data/test/reindex_test.rb

@@ -48,7 +48,5 @@ class ReindexTest < Minitest::Test
     Product.search_index.promote(index.name, update_refresh_interval: true)
     assert_equal "1s", index.refresh_interval
     assert_equal "1s", Product.search_index.refresh_interval
-  ensure
-    Product.reindex
   end
 end

data/test/test_helper.rb

@@ -14,7 +14,13 @@ File.delete("elasticsearch.log") if File.exist?("elasticsearch.log")
 Searchkick.client.transport.logger = Logger.new("elasticsearch.log")
 Searchkick.search_timeout = 5
 
-Searchkick.redis = Redis.new if defined?(Redis)
+if defined?(Redis)
+  if defined?(ConnectionPool)
+    Searchkick.redis = ConnectionPool.new { Redis.new }
+  else
+    Searchkick.redis = Redis.new
+  end
+end
 
 puts "Running against Elasticsearch #{Searchkick.server_version}"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-16 00:00:00.000000000 Z
+date: 2017-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -189,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Searchkick learns what your users are looking for. As more people search,