searchkick 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b43a0209f8d9f4e32f3c21c190ea82d5f2a0b4b
-  data.tar.gz: 016d4568bfd949ba047e6ce59024f795861f24d6
+  metadata.gz: 9afc0023095cdc587ed6df4faedb9c6ba0927b61
+  data.tar.gz: ff38cab705eb7d2692e81510ff237707820f1bda
 SHA512:
-  metadata.gz: 76307b462984c715a68d9e0e71edd0139811a3274ad9682ad97034ac2ceb9f9b74b5094750a53ac8c449db5f1b4c5d6be6f5cdb22e1aa19a8b21fd7230f31798
-  data.tar.gz: 236fbf2c4e83877a03eed6728263b6af62094ee1139e88fd3ec86a4fd6da8269fcd2972f29f5bf2bafd3e667f7ee5ce40945509ea56c24f4d3746e4fed688be6
+  metadata.gz: af68e2a80fc2f8cead9075b8e2e2928ab81dcf98952949f2901d24f151de235b5e648316dce80c84b9197d6b549efc43fb9ed1f04e8f79a8a834e671e68171aa
+  data.tar.gz: b0a23d33695f2b82d84eb2152b07ca43d610ff1ba2200b917baaba61c3a7e8e7292161108270800afba3673484fefc8f19a7757ff2cbac0d131e7c36cccd3a5c

data/README.md

@@ -16,6 +16,9 @@ Plus:
 
 - query like SQL - no need to learn a new query language
 - reindex without downtime
+- easily personalize results for each user
+- autocomplete
+- “Did you mean” suggestions
 
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com)
 
@@ -129,6 +132,24 @@ To change this, use:
 Product.search "fresh honey", partial: true # fresh OR honey
 ```
 
+### Autocomplete
+
+![Autocomplete](http://ankane.github.io/searchkick/autocomplete.png)
+
+You must specify which fields use this feature since this can increase the index size significantly.  Don’t worry - this gives you blazing faster queries.
+
+```ruby
+class Website < ActiveRecord::Base
+  searchkick autocomplete: ["title"]
+end
+```
+
+Reindex and search with:
+
+```ruby
+Website.search "where", autocomplete: true
+```
+
 ### Synonyms
 
 ```ruby
@@ -137,11 +158,11 @@ class Product < ActiveRecord::Base
 end
 ```
 
-You must call `Product.reindex` after changing synonyms.
+Call `Product.reindex` after changing synonyms.
 
 ### Indexing
 
-Control what data is indexed with the `search_data` method.
+Control what data is indexed with the `search_data` method. Call `Product.reindex` after changing this method.
 
 ```ruby
 class Product < ActiveRecord::Base
@@ -182,14 +203,19 @@ end
 
 Add conversions to the index.
 
+**Note**: You must specify the conversions field as of version `0.2.0`.
+
 ```ruby
 class Product < ActiveRecord::Base
   has_many :searches
 
+  searchkick conversions: "conversions" # name of field
+
   def search_data
     {
       name: name,
       conversions: searches.group("query").count
+      # {"ice cream" => 234, "chocolate" => 67, "cream" => 2}
     }
   end
 end
@@ -201,11 +227,56 @@ Reindex and set up a cron job to add new conversions daily.
 rake searchkick:reindex CLASS=Product
 ```
 
+### Personalized Results
+
+Order results differently for each user.  For example, show a user’s previously purchased products before other results.
+
+```ruby
+class Product < ActiveRecord::Base
+  searchkick personalize: "user_ids"
+
+  def search_data
+    {
+      name: name,
+      user_ids: orders.pluck(:user_id) # boost this product for these users
+      # [4, 8, 15, 16, 23, 42]
+    }
+  end
+end
+```
+
+Reindex and search with:
+
+```ruby
+Product.search "milk", user_id: 8
+```
+
+### Suggestions
+
+![Suggest](http://ankane.github.io/searchkick/recursion.png)
+
+```ruby
+class Product < ActiveRecord::Base
+  searchkick suggest: ["name"] # fields to generate suggestions
+end
+```
+
+Reindex and search with:
+
+```ruby
+products = Product.search "peantu butta", suggest: true
+products.suggestions # ["peanut butter"]
+```
+
 ### Facets
 
+[Facets](http://www.elasticsearch.org/guide/reference/api/search/facets/) provide aggregated search data.
+
+![Facets](http://ankane.github.io/searchkick/facets.png)
+
 ```ruby
-search = Product.search "2% Milk", facets: [:store_id, :aisle_id]
-p search.facets
+products = Product.search "chuck taylor", facets: [:product_type, :gender, :brand]
+p products.facets
 ```
 
 Advanced
@@ -323,13 +394,11 @@ end
 
 ## Thanks
 
-Thanks to Karel Minarik for [Tire](https://github.com/karmi/tire) and Jaroslav Kalistsuk for [zero downtime reindexing](https://gist.github.com/jarosan/3124884).
+Thanks to Karel Minarik for [Tire](https://github.com/karmi/tire), Jaroslav Kalistsuk for [zero downtime reindexing](https://gist.github.com/jarosan/3124884), and Alex Leschenko for [Elasticsearch autocomplete](https://github.com/leschenko/elasticsearch_autocomplete).
 
 ## TODO
 
-- Custom results for each user
 - Make Searchkick work with any language
-- Built-in synonyms from WordNet
 
 ## Contributing
 

data/lib/searchkick.rb

@@ -1,9 +1,10 @@
+require "tire"
 require "searchkick/version"
 require "searchkick/reindex"
+require "searchkick/results"
 require "searchkick/search"
 require "searchkick/model"
 require "searchkick/tasks"
-require "tire"
 
 # TODO find better ActiveModel hook
 ActiveModel::AttributeMethods::ClassMethods.send(:include, Searchkick::Model)

data/lib/searchkick/model.rb

@@ -3,7 +3,6 @@ module Searchkick
 
     def searchkick(options = {})
       @searchkick_options = options.dup
-      @searchkick_options[:conversions] = true if options[:conversions].nil?
 
       class_eval do
         extend Searchkick::Search
@@ -24,9 +23,23 @@ module Searchkick
 
         def to_indexed_json
           source = search_data
-          if self.class.instance_variable_get("@searchkick_options")[:conversions] and source[:conversions]
-            source[:conversions] = source[:conversions].map{|k, v| {query: k, count: v} }
+
+          # stringify fields
+          source = source.inject({}){|memo,(k,v)| memo[k.to_s] = v; memo}
+
+          options = self.class.instance_variable_get("@searchkick_options")
+
+          # conversions
+          conversions_field = options[:conversions]
+          if conversions_field and source[conversions_field]
+            source[conversions_field] = source[conversions_field].map{|k, v| {query: k, count: v} }
           end
+
+          # hack to prevent generator field doesn't exist error
+          (options[:suggest] || []).map(&:to_s).each do |field|
+            source[field] = "a" if !source[field]
+          end
+
           source.to_json
         end
       end

data/lib/searchkick/reindex.rb

@@ -7,7 +7,8 @@ module Searchkick
       new_index = alias_name + "_" + Time.now.strftime("%Y%m%d%H%M%S")
       index = Tire::Index.new(new_index)
 
-      index.create searchkick_index_options
+      success = index.create searchkick_index_options
+      raise index.response.to_s if !success
 
       # use scope for import
       scope = respond_to?(:search_import) ? search_import : self
@@ -67,6 +68,22 @@ module Searchkick
               type: "custom",
               tokenizer: "standard",
               filter: ["standard", "lowercase", "asciifolding", "stop", "snowball"]
+            },
+            # https://github.com/leschenko/elasticsearch_autocomplete/blob/master/lib/elasticsearch_autocomplete/analyzers.rb
+            searchkick_autocomplete_index: {
+              type: "custom",
+              tokenizer: "searchkick_autocomplete_ngram",
+              filter: ["lowercase", "asciifolding"]
+            },
+            searchkick_autocomplete_search: {
+              type: "custom",
+              tokenizer: "keyword",
+              filter: ["lowercase", "asciifolding"]
+            },
+            searchkick_suggest_index: {
+              type: "custom",
+              tokenizer: "standard",
+              filter: ["lowercase", "asciifolding", "searchkick_suggest_shingle"]
             }
           },
           filter: {
@@ -80,28 +97,45 @@ module Searchkick
               token_separator: "",
               output_unigrams: false,
               output_unigrams_if_no_shingles: true
+            },
+            searchkick_suggest_shingle: {
+              type: "shingle",
+              max_shingle_size: 5
+            }
+          },
+          tokenizer: {
+            searchkick_autocomplete_ngram: {
+              type: "edgeNGram",
+              min_gram: 1,
+              max_gram: 50
             }
           }
         }
       }.merge(options[:settings] || {})
+
+      # synonyms
       synonyms = options[:synonyms] || []
       if synonyms.any?
         settings[:analysis][:filter][:searchkick_synonym] = {
           type: "synonym",
-          ignore_case: true,
-          synonyms: synonyms.select{|s| s.size > 1 }.map{|s| "#{s[0..-2].join(",")} => #{s[-1]}" }
+          synonyms: synonyms.select{|s| s.size > 1 }.map{|s| s.join(",") }
         }
         # choosing a place for the synonym filter when stemming is not easy
         # https://groups.google.com/forum/#!topic/elasticsearch/p7qcQlgHdB8
         # TODO use a snowball stemmer on synonyms when creating the token filter
-        settings[:analysis][:analyzer][:default_index][:filter].insert(-4, "searchkick_synonym")
+
+        # http://elasticsearch-users.115913.n3.nabble.com/synonym-multi-words-search-td4030811.html
+        # I find the following approach effective if you are doing multi-word synonyms (synonym phrases):
+        # - Only apply the synonym expansion at index time
+        # - Don't have the synonym filter applied search
+        # - Use directional synonyms where appropriate. You want to make sure that you're not injecting terms that are too general.
+        settings[:analysis][:analyzer][:default_index][:filter].insert(4, "searchkick_synonym")
         settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_synonym"
-        settings[:analysis][:analyzer][:searchkick_search][:filter].insert(-4, "searchkick_synonym")
-        settings[:analysis][:analyzer][:searchkick_search][:filter] << "searchkick_synonym"
-        settings[:analysis][:analyzer][:searchkick_search2][:filter] << "searchkick_synonym"
       end
 
       mapping = {}
+
+      # conversions
       if options[:conversions]
         mapping[:conversions] = {
           type: "nested",
@@ -112,6 +146,26 @@ module Searchkick
         }
       end
 
+      # autocomplete and suggest
+      autocomplete = (options[:autocomplete] || []).map(&:to_s)
+      suggest = (options[:suggest] || []).map(&:to_s)
+      (autocomplete + suggest).uniq.each do |field|
+        field_mapping = {
+          type: "multi_field",
+          fields: {
+            field => {type: "string", index: "not_analyzed"},
+            "analyzed" => {type: "string", index: "analyzed"}
+          }
+        }
+        if autocomplete.include?(field)
+          field_mapping[:fields]["autocomplete"] = {type: "string", index: "analyzed", analyzer: "searchkick_autocomplete_index"}
+        end
+        if suggest.include?(field)
+          field_mapping[:fields]["suggest"] = {type: "string", index: "analyzed", analyzer: "searchkick_suggest_index"}
+        end
+        mapping[field] = field_mapping
+      end
+
       mappings = {
         document_type.to_sym => {
           properties: mapping,

data/lib/searchkick/results.rb

@@ -0,0 +1,17 @@
+module Searchkick
+  class Results < Tire::Results::Collection
+
+    def suggestions
+      if @response["suggest"]
+        @response["suggest"].values.flat_map{|v| v.first["options"] }.sort_by{|o| -o["score"] }.map{|o| o["text"] }.uniq
+      else
+        raise "Pass `suggest: true` to the search method for suggestions"
+      end
+    end
+
+    # fixes deprecation warning
+    def __find_records_by_ids(klass, ids)
+      @options[:load] === true ? klass.find(ids) : klass.includes(@options[:load][:include]).find(ids)
+    end
+  end
+end

data/lib/searchkick/search.rb

@@ -3,56 +3,93 @@ module Searchkick
 
     def search(term, options = {})
       term = term.to_s
-      fields = options[:fields] ? options[:fields].map{|f| "#{f}.analyzed" } : ["_all"]
+      fields =
+        if options[:fields]
+          if options[:autocomplete]
+            options[:fields].map{|f| "#{f}.autocomplete" }
+          else
+            options[:fields].map{|f| "#{f}.analyzed" }
+          end
+        else
+          if options[:autocomplete]
+            (@searchkick_options[:autocomplete] || []).map{|f| "#{f}.autocomplete" }
+          else
+            ["_all"]
+          end
+        end
+
       operator = options[:partial] ? "or" : "and"
+
+      # model and eagar loading
       load = options[:load].nil? ? true : options[:load]
       load = (options[:include] ? {include: options[:include]} : true) if load
+
+      # pagination
       page = options.has_key?(:page) ? [options[:page].to_i, 1].max : nil
-      tire_options = {
-        load: load,
-        page: page,
-        per_page: options[:limit] || options[:per_page] || 100000 # return all
-      }
-      tire_options[:index] = options[:index_name] if options[:index_name]
-
-      collection =
-        tire.search tire_options do
+      per_page = options[:limit] || options[:per_page] || 100000
+      offset = options[:offset] || (page && (page - 1) * per_page)
+      index_name = options[:index_name] || index.name
+
+      conversions_field = @searchkick_options[:conversions]
+      personalize_field = @searchkick_options[:personalize]
+
+      # TODO lose Tire DSL for more flexibility
+      s =
+        Tire::Search::Search.new do
           query do
-            boolean do
-              must do
-                # TODO escape boost field
-                score_script = options[:boost] ? "_score * log(doc['#{options[:boost]}'].value + 2.718281828)" : "_score"
-                custom_score script: score_script do
-                  dis_max do
-                    query do
-                      match fields, term, boost: 10, operator: operator, analyzer: "searchkick_search"
-                    end
-                    query do
-                      match fields, term, boost: 10, operator: operator, analyzer: "searchkick_search2"
-                    end
-                    query do
-                      match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search"
-                    end
-                    query do
-                      match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search2"
+            custom_filters_score do
+              query do
+                boolean do
+                  must do
+                    if options[:autocomplete]
+                      match fields, term, analyzer: "searchkick_autocomplete_search"
+                    else
+                      dis_max do
+                        query do
+                          match fields, term, use_dis_max: false, boost: 10, operator: operator, analyzer: "searchkick_search"
+                        end
+                        query do
+                          match fields, term, use_dis_max: false, boost: 10, operator: operator, analyzer: "searchkick_search2"
+                        end
+                        query do
+                          match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search"
+                        end
+                        query do
+                          match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 1, operator: operator, analyzer: "searchkick_search2"
+                        end
+                      end
                     end
                   end
-                end
-              end
-              unless options[:conversions] == false
-                should do
-                  nested path: "conversions", score_mode: "total" do
-                    query do
-                      custom_score script: "doc['count'].value" do
-                        match "query", term
+                  if conversions_field and options[:conversions] != false
+                    should do
+                      nested path: conversions_field, score_mode: "total" do
+                        query do
+                          custom_score script: "doc['count'].value" do
+                            match "query", term
+                          end
+                        end
                       end
                     end
                   end
                 end
               end
+              if options[:boost]
+                filter do
+                  filter :exists, field: options[:boost]
+                  script "log(doc['#{options[:boost]}'].value + 2.718281828)"
+                end
+              end
+              if options[:user_id] and personalize_field
+                filter do
+                  filter :term, personalize_field => options[:user_id]
+                  boost 100
+                end
+              end
+              score_mode "total"
             end
           end
-          from options[:offset] if options[:offset]
+          size per_page
+          from offset if offset
           explain options[:explain] if options[:explain]
 
           # order
@@ -143,7 +180,27 @@ module Searchkick
           end
         end
 
-      collection
+      payload = s.to_hash
+
+      # suggestions
+      if options[:suggest]
+        suggest_fields = (@searchkick_options[:suggest] || []).map(&:to_s)
+        # intersection
+        suggest_fields = suggest_fields & options[:fields].map(&:to_s) if options[:fields]
+        if suggest_fields.any?
+          payload[:suggest] = {text: term}
+          suggest_fields.each do |field|
+            payload[:suggest][field] = {
+              phrase: {
+                field: "#{field}.suggest"
+              }
+            }
+          end
+        end
+      end
+
+      search = Tire::Search::Search.new(index_name, load: load, payload: payload)
+      Searchkick::Results.new(search.json, search.options.merge(term: term))
     end
 
   end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/test/boost_test.rb

@@ -46,4 +46,14 @@ class TestBoost < Minitest::Unit::TestCase
     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
+
 end

data/test/match_test.rb

@@ -60,14 +60,21 @@ class TestMatch < Minitest::Unit::TestCase
     assert_search "fin", ["Finn"]
   end
 
-  def test_edit_distance
+  def test_edit_distance_two
     store_names ["Bingo"]
     assert_search "bin", []
+    assert_search "bingooo", []
+    assert_search "mango", []
+  end
+
+  def test_edit_distance_one
+    store_names ["Bingo"]
     assert_search "bing", ["Bingo"]
     assert_search "bingoo", ["Bingo"]
-    assert_search "bingooo", []
     assert_search "ringo", ["Bingo"]
-    assert_search "mango", []
+  end
+
+  def test_edit_distance_long_word
     store_names ["thisisareallylongword"]
     assert_search "thisisareallylongwor", ["thisisareallylongword"] # missing letter
     assert_search "thisisareelylongword", [] # edit distance = 2
@@ -110,4 +117,21 @@ class TestMatch < Minitest::Unit::TestCase
     assert_search "almondmilks", ["Almond Milk"]
   end
 
+  # autocomplete
+
+  def test_autocomplete
+    store_names ["Hummus"]
+    assert_search "hum", ["Hummus"], autocomplete: true
+  end
+
+  def test_autocomplete_two_words
+    store_names ["Organic Hummus"]
+    assert_search "hum", [], autocomplete: true
+  end
+
+  def test_autocomplete_fields
+    store_names ["Hummus"]
+    assert_search "hum", ["Hummus"], autocomplete: true, fields: [:name]
+  end
+
 end

data/test/sql_test.rb

@@ -7,6 +7,12 @@ class TestSql < Minitest::Unit::TestCase
     assert_order "product", ["Product A", "Product B"], order: {name: :asc}, limit: 2
   end
 
+  def test_no_limit
+    names = 20.times.map{|i| "Product #{i}" }
+    store_names names
+    assert_search "product", names
+  end
+
   def test_offset
     store_names ["Product A", "Product B", "Product C", "Product D"]
     assert_order "product", ["Product C", "Product D"], order: {name: :asc}, offset: 2
@@ -81,6 +87,19 @@ class TestSql < Minitest::Unit::TestCase
     assert_search "blue", ["red"], fields: ["color"]
   end
 
+  def test_non_existent_field
+    store_names ["Milk"]
+    assert_search "milk", [], fields: ["not_here"]
+  end
+
+  def test_fields_both_match
+    store [
+      {name: "Blue A", color: "red"},
+      {name: "Blue B", color: "light blue"}
+    ]
+    assert_first "blue", "Blue B", fields: [:name, :color]
+  end
+
   # load
 
   def test_load_default

data/test/suggest_test.rb

@@ -0,0 +1,70 @@
+require_relative "test_helper"
+
+class TestSuggest < Minitest::Unit::TestCase
+
+  def test_basic
+    store_names ["Great White Shark", "Hammerhead Shark", "Tiger Shark"]
+    assert_suggest "How Big is a Tigre Shar", "how big is a tiger shark"
+  end
+
+  def test_perfect
+    store_names ["Tiger Shark", "Great White Shark"]
+    assert_suggest "Tiger Shark", nil # no correction
+  end
+
+  def test_phrase
+    store_names ["Big Tiger Shark", "Tiger Sharp Teeth", "Tiger Sharp Mind"]
+    assert_suggest "How to catch a big tiger shar", "how to catch a big tiger shark"
+  end
+
+  def test_without_option
+    assert_raises(RuntimeError){ Product.search("hi").suggestions }
+  end
+
+  def test_multiple_fields
+    store [
+      {name: "Shark", color: "Sharp"}
+    ]
+    assert_suggest_all "shar", ["shark", "sharp"]
+  end
+
+  def test_multiple_fields_highest_score_first
+    store [
+      {name: "Tiger Shark", color: "Sharp"}
+    ]
+    assert_suggest "tiger shar", "tiger shark"
+  end
+
+  def test_multiple_fields_same_value
+    store [
+      {name: "Shark", color: "Shark"}
+    ]
+    assert_suggest_all "shar", ["shark"]
+  end
+
+  def test_fields_option
+    store [
+      {name: "Shark", color: "Sharp"}
+    ]
+    assert_suggest_all "shar", ["shark"], fields: [:name]
+  end
+
+  def test_fields_option_multiple
+    store [
+      {name: "Shark"}
+    ]
+    assert_suggest "shar", "shark", fields: [:name, :unknown]
+  end
+
+  protected
+
+  def assert_suggest(term, expected, options = {})
+    assert_equal expected, Product.search(term, options.merge(suggest: true)).suggestions.first
+  end
+
+  # any order
+  def assert_suggest_all(term, expected, options = {})
+    assert_equal expected.sort, Product.search(term, options.merge(suggest: true)).suggestions.sort
+  end
+
+end

data/test/test_helper.rb

@@ -44,15 +44,19 @@ class Product < ActiveRecord::Base
       ["clorox", "bleach"],
       ["scallion", "greenonion"],
       ["saranwrap", "plasticwrap"],
-      ["qtip", "cotton swab"],
+      ["qtip", "cottonswab"],
       ["burger", "hamburger"],
       ["bandaid", "bandag"]
-    ]
+    ],
+    autocomplete: [:name],
+    suggest: [:name, :color],
+    conversions: "conversions",
+    personalize: "user_ids"
 
-  attr_accessor :conversions
+  attr_accessor :conversions, :user_ids
 
   def search_data
-    as_json.merge conversions: conversions
+    as_json.merge conversions: conversions, user_ids: user_ids
   end
 end
 
@@ -70,7 +74,7 @@ class MiniTest::Unit::TestCase
   protected
 
   def store(documents)
-    documents.each do |document|
+    documents.shuffle.each do |document|
       Product.create!(document)
     end
     Product.index.refresh
@@ -89,4 +93,8 @@ class MiniTest::Unit::TestCase
     assert_equal expected, Product.search(term, options).map(&:name)
   end
 
+  def assert_first(term, expected, options = {})
+    assert_equal expected, Product.search(term, options).map(&:name).first
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-04 00:00:00.000000000 Z
+date: 2013-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tire
@@ -109,6 +109,7 @@ files:
 - lib/searchkick.rb
 - lib/searchkick/model.rb
 - lib/searchkick/reindex.rb
+- lib/searchkick/results.rb
 - lib/searchkick/search.rb
 - lib/searchkick/tasks.rb
 - lib/searchkick/version.rb
@@ -117,6 +118,7 @@ files:
 - test/facets_test.rb
 - test/match_test.rb
 - test/sql_test.rb
+- test/suggest_test.rb
 - test/synonyms_test.rb
 - test/test_helper.rb
 homepage: https://github.com/ankane/searchkick
@@ -148,5 +150,6 @@ test_files:
 - test/facets_test.rb
 - test/match_test.rb
 - test/sql_test.rb
+- test/suggest_test.rb
 - test/synonyms_test.rb
 - test/test_helper.rb