searchkick 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12242ee03581e51bcb73eb5301309a0ba85b0c8b
-  data.tar.gz: 94f6e444569e05c8d1a56054da8f079cdf43bf50
+  metadata.gz: 35f9202e63447e7c182bd2a34737e7a519888e91
+  data.tar.gz: 19a7a8d24dd5ff687687e235c64971cb979f42f2
 SHA512:
-  metadata.gz: 56a50ceacda73f6aee353c22b84191d721afe481808ed69beb7d79601d4e6cd57deed76ac8f70f4ccc37d753ee4d16758b5b269359cbd79ec363180290c4ee99
-  data.tar.gz: 71953014b0b9233519f0088da6d3246a2f45fa3babff843dcce2143b0b9f24b8ddeb0523418b5b764485785921c11a2ad6f723b028cd84d420162bba15bf4438
+  metadata.gz: 762a4b1e6ce4a31e2a3d75ac235954222f26c3d5361d0bb8fd1504aeaf3f294c0f569a15208d1e2e38428715bdaa1bdc879356b2040bff5bb313f763e3091ccc
+  data.tar.gz: 1f7c6ea8338b6fe7479a22a55d523a753903fd703f142522806b83926be3cf3b20d10b1b2c39eb507657af97f48e84372d1c6cb102e10fe6a05ea40031eefe16

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 1.1.0
+
+- Added `below` option to misspellings to improve performance
+- Fixed synonyms for `word_*` partial matches
+- Added `searchable` option
+- Added `similarity` option
+- Added `match` option
+- Added `word` option
+- Added highlighted fields to `load: false`
+
 ## 1.0.3
 
 - Added support for Elasticsearch 2.1

data/README.md

@@ -127,7 +127,7 @@ Searches return a `Searchkick::Results` object. This responds like an array to m
 results = Product.search("milk")
 results.size
 results.any?
-results.each { ... }
+results.each { |result| ... }
 ```
 
 Get total results
@@ -227,7 +227,7 @@ end
 And to search (after you reindex):
 
 ```ruby
-Product.search "back", fields: [{name: :word_start}]
+Product.search "back", fields: [:name], match: :word_start
 ```
 
 Available options are:
@@ -242,16 +242,10 @@ Available options are:
 :text_end
 ```
 
-To boost fields, use:
-
-```ruby
-fields: [{"name^2" => :word_start}] # better interface on the way
-```
-
 ### Exact Matches
 
 ```ruby
-User.search "hi@searchkick.org", fields: [{email: :exact}, :name]
+User.search params[:q], fields: [{email: :exact}, :name]
 ```
 
 ### Language
@@ -309,7 +303,15 @@ You can change this with:
 Product.search "zucini", misspellings: {edit_distance: 2} # zucchini
 ```
 
-Or turn off misspellings with:
+To improve performance for correctly spelled queries (which should be a majority for most applications), Searchkick can first perform a search without misspellings, and if there are few results, perform another with them. [master]
+
+```ruby
+Product.search "zuchini", misspellings: {below: 5}
+```
+
+If there are fewer than 5 results, a 2nd search is performed for misspellings.
+
+Turn off misspellings with:
 
 ```ruby
 Product.search "zuchini", misspellings: false # no zucchini
@@ -498,14 +500,14 @@ First, specify which fields use this feature.  This is necessary since autocompl
 
 ```ruby
 class City < ActiveRecord::Base
-  searchkick text_start: [:name]
+  searchkick match: :word_start
 end
 ```
 
 Reindex and search with:
 
 ```ruby
-City.search "san fr", fields: [{name: :text_start}]
+City.search "san fr", fields: [:name]
 ```
 
 Typically, you want to use a JavaScript library like [typeahead.js](http://twitter.github.io/typeahead.js/) or [jQuery UI](http://jqueryui.com/autocomplete/).
@@ -517,11 +519,9 @@ First, add a route and controller action.
 ```ruby
 # app/controllers/cities_controller.rb
 class CitiesController < ApplicationController
-
   def autocomplete
-    render json: City.search(params[:query], fields: [{name: :text_start}], limit: 10).map(&:name)
+    render json: City.search(params[:query], fields: [:name], limit: 10).map(&:name)
   end
-
 end
 ```
 
@@ -546,7 +546,7 @@ Then add the search box and JavaScript code to a view.
 
 ```ruby
 class Product < ActiveRecord::Base
-  searchkick suggest: ["name"] # fields to generate suggestions
+  searchkick suggest: [:name] # fields to generate suggestions
 end
 ```
 
@@ -1147,6 +1147,14 @@ class Product < ActiveRecord::Base
 end
 ```
 
+Use [Okapi BM25](https://www.elastic.co/guide/en/elasticsearch/guide/current/pluggable-similarites.html) for ranking [master]
+
+```ruby
+class Product < ActiveRecord::Base
+  searchkick similarity: "BM25"
+end
+```
+
 Change import batch size
 
 ```ruby

data/lib/searchkick/index.rb

@@ -353,6 +353,10 @@ module Searchkick
           settings.merge!(number_of_shards: 1, number_of_replicas: 0)
         end
 
+        if options[:similarity]
+          settings[:similarity] = {default: {type: options[:similarity]}}
+        end
+
         settings.deep_merge!(options[:settings] || {})
 
         # synonyms
@@ -376,6 +380,10 @@ module Searchkick
           # - 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"
+
+          %w(word_start word_middle word_end).each do |type|
+            settings[:analysis][:analyzer]["searchkick_#{type}_index".to_sym][:filter].insert(2, "searchkick_synonym")
+          end
         end
 
         if options[:wordnet]
@@ -387,6 +395,10 @@ module Searchkick
 
           settings[:analysis][:analyzer][:default_index][:filter].insert(4, "searchkick_wordnet")
           settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_wordnet"
+
+          %w(word_start word_middle word_end).each do |type|
+            settings[:analysis][:analyzer]["searchkick_#{type}_index".to_sym][:filter].insert(2, "searchkick_wordnet")
+          end
         end
 
         if options[:special_characters] == false
@@ -409,29 +421,34 @@ module Searchkick
         end
 
         mapping_options = Hash[
-          [:autocomplete, :suggest, :text_start, :text_middle, :text_end, :word_start, :word_middle, :word_end, :highlight]
+          [:autocomplete, :suggest, :word, :text_start, :text_middle, :text_end, :word_start, :word_middle, :word_end, :highlight, :searchable]
             .map { |type| [type, (options[type] || []).map(&:to_s)] }
         ]
 
+        word = options[:word] != false && (!options[:match] || options[:match] == :word)
+
         mapping_options.values.flatten.uniq.each do |field|
           field_mapping = {
             type: "multi_field",
             fields: {
-              field => {type: "string", index: "not_analyzed"},
-              "analyzed" => {type: "string", index: "analyzed"}
-              # term_vector: "with_positions_offsets" for fast / correct highlighting
-              # http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-request-highlighting.html#_fast_vector_highlighter
+              field => {type: "string", index: "not_analyzed"}
             }
           }
 
-          mapping_options.except(:highlight).each do |type, fields|
-            if fields.include?(field)
-              field_mapping[:fields][type] = {type: "string", index: "analyzed", analyzer: "searchkick_#{type}_index"}
+          if !options[:searchable] || mapping_options[:searchable].include?(field)
+            if word
+              field_mapping[:fields]["analyzed"] = {type: "string", index: "analyzed"}
+
+              if mapping_options[:highlight].include?(field)
+                field_mapping[:fields]["analyzed"][:term_vector] = "with_positions_offsets"
+              end
             end
-          end
 
-          if mapping_options[:highlight].include?(field)
-            field_mapping[:fields]["analyzed"][:term_vector] = "with_positions_offsets"
+            mapping_options.except(:highlight, :searchable).each do |type, fields|
+              if options[:match] == type || fields.include?(field)
+                field_mapping[:fields][type] = {type: "string", index: "analyzed", analyzer: "searchkick_#{type}_index"}
+              end
+            end
           end
 
           mapping[field] = field_mapping
@@ -455,6 +472,24 @@ module Searchkick
           routing = {required: true, path: options[:routing].to_s}
         end
 
+        dynamic_fields = {
+          # analyzed field must be the default field for include_in_all
+          # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
+          # however, we can include the not_analyzed field in _all
+          # and the _all index analyzer will take care of it
+          "{name}" => {type: "string", index: "not_analyzed", include_in_all: !options[:searchable]}
+        }
+
+        unless options[:searchable]
+          if options[:match] && options[:match] != :word
+            dynamic_fields[options[:match]] = {type: "string", index: "analyzed", analyzer: "searchkick_#{options[:match]}_index"}
+          end
+
+          if word
+            dynamic_fields["analyzed"] = {type: "string", index: "analyzed"}
+          end
+        end
+
         mappings = {
           _default_: {
             properties: mapping,
@@ -468,14 +503,7 @@ module Searchkick
                   mapping: {
                     # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
                     type: "multi_field",
-                    fields: {
-                      # analyzed field must be the default field for include_in_all
-                      # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
-                      # however, we can include the not_analyzed field in _all
-                      # and the _all index analyzer will take care of it
-                      "{name}" => {type: "string", index: "not_analyzed"},
-                      "analyzed" => {type: "string", index: "analyzed"}
-                    }
+                    fields: dynamic_fields
                   }
                 }
               }

data/lib/searchkick/logging.rb

@@ -2,16 +2,16 @@
 
 module Searchkick
   class Query
-    def execute_with_instrumentation
+    def execute_search_with_instrumentation
       event = {
         name: "#{searchkick_klass.name} Search",
         query: params
       }
       ActiveSupport::Notifications.instrument("search.searchkick", event) do
-        execute_without_instrumentation
+        execute_search_without_instrumentation
       end
     end
-    alias_method_chain :execute, :instrumentation
+    alias_method_chain :execute_search, :instrumentation
   end
 
   class Index

data/lib/searchkick/query.rb

@@ -22,15 +22,114 @@ module Searchkick
       @klass = klass
       @term = term
       @options = options
+      @match_suffix = options[:match] || searchkick_options[:match] || "analyzed"
 
+      prepare
+    end
+
+    def searchkick_index
+      klass.searchkick_index
+    end
+
+    def searchkick_options
+      klass.searchkick_options
+    end
+
+    def searchkick_klass
+      klass.searchkick_klass
+    end
+
+    def params
+      params = {
+        index: options[:index_name] || searchkick_index.name,
+        body: body
+      }
+      params.merge!(type: @type) if @type
+      params.merge!(routing: @routing) if @routing
+      params
+    end
+
+    def execute
+      @execute ||= begin
+        begin
+          response = execute_search
+          if @misspellings_below && response["hits"]["total"] < @misspellings_below
+            prepare
+            response = execute_search
+          end
+        rescue => e # TODO rescue type
+          status_code = e.message[1..3].to_i
+          if status_code == 404
+            raise MissingIndexError, "Index missing - run #{searchkick_klass.name}.reindex"
+          elsif status_code == 500 && (
+              e.message.include?("IllegalArgumentException[minimumSimilarity >= 1]") ||
+              e.message.include?("No query registered for [multi_match]") ||
+              e.message.include?("[match] query does not support [cutoff_frequency]]") ||
+              e.message.include?("No query registered for [function_score]]")
+            )
+
+            raise UnsupportedVersionError, "This version of Searchkick requires Elasticsearch 1.0 or greater"
+          elsif status_code == 400
+            if e.message.include?("[multi_match] analyzer [searchkick_search] not found")
+              raise InvalidQueryError, "Bad mapping - run #{searchkick_klass.name}.reindex"
+            else
+              raise InvalidQueryError, e.message
+            end
+          else
+            raise e
+          end
+        end
+
+        # apply facet limit in client due to
+        # https://github.com/elasticsearch/elasticsearch/issues/1305
+        @facet_limits.each do |field, limit|
+          field = field.to_s
+          facet = response["facets"][field]
+          response["facets"][field]["terms"] = facet["terms"].first(limit)
+          response["facets"][field]["other"] = facet["total"] - facet["terms"].sum { |term| term["count"] }
+        end
+
+        opts = {
+          page: @page,
+          per_page: @per_page,
+          padding: @padding,
+          load: @load,
+          includes: options[:include] || options[:includes],
+          json: !options[:json].nil?,
+          match_suffix: @match_suffix,
+          highlighted_fields: @highlighted_fields || []
+        }
+        Searchkick::Results.new(searchkick_klass, response, opts)
+      end
+    end
+
+    def to_curl
+      query = params
+      type = query[:type]
+      index = query[:index].is_a?(Array) ? query[:index].join(",") : query[:index]
+
+      # no easy way to tell which host the client will use
+      host = Searchkick.client.transport.hosts.first
+      credentials = (host[:user] || host[:password]) ? "#{host[:user]}:#{host[:password]}@" : nil
+      "curl #{host[:protocol]}://#{credentials}#{host[:host]}:#{host[:port]}/#{CGI.escape(index)}#{type ? "/#{type.map { |t| CGI.escape(t) }.join(',')}" : ''}/_search?pretty -d '#{query[:body].to_json}'"
+    end
+
+    private
+
+    def execute_search
+      Searchkick.client.search(params)
+    end
+
+    def prepare
       boost_fields = {}
+      fields = options[:fields] || searchkick_options[:searchable]
       fields =
-        if options[:fields]
+        if fields
           if options[:autocomplete]
-            options[:fields].map { |f| "#{f}.autocomplete" }
+            fields.map { |f| "#{f}.autocomplete" }
           else
-            options[:fields].map do |value|
-              k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
+            fields.map do |value|
+              k, v = value.is_a?(Hash) ? value.to_a.first : [value, options[:match] || searchkick_options[:match] || :word]
               k2, boost = k.to_s.split("^", 2)
               field = "#{k2}.#{v == :word ? 'analyzed' : v}"
               boost_fields[field] = boost.to_f if boost
@@ -93,6 +192,36 @@ module Searchkick
             }
           else
             queries = []
+
+            misspellings =
+              if options.key?(:misspellings)
+                options[:misspellings]
+              elsif options.key?(:mispellings)
+                options[:mispellings] # why not?
+              else
+                true
+              end
+
+            if misspellings.is_a?(Hash) && misspellings[:below] && !@misspellings_below
+              @misspellings_below = misspellings[:below].to_i
+              misspellings = false
+            end
+
+            if misspellings != false
+              edit_distance = (misspellings.is_a?(Hash) && (misspellings[:edit_distance] || misspellings[:distance])) || 1
+              transpositions =
+                if misspellings.is_a?(Hash) && misspellings.key?(:transpositions)
+                  {fuzzy_transpositions: misspellings[:transpositions]}
+                elsif below14?
+                  {}
+                else
+                  {fuzzy_transpositions: true}
+                end
+              prefix_length = (misspellings.is_a?(Hash) && misspellings[:prefix_length]) || 0
+              default_max_expansions = @misspellings_below ? 20 : 3
+              max_expansions = (misspellings.is_a?(Hash) && misspellings[:max_expansions]) || default_max_expansions
+            end
+
             fields.each do |field|
               qs = []
 
@@ -103,29 +232,6 @@ module Searchkick
                 boost: 10 * factor
               }
 
-              misspellings =
-                if options.key?(:misspellings)
-                  options[:misspellings]
-                elsif options.key?(:mispellings)
-                  options[:mispellings] # why not?
-                else
-                  true
-                end
-
-              if misspellings != false
-                edit_distance = (misspellings.is_a?(Hash) && (misspellings[:edit_distance] || misspellings[:distance])) || 1
-                transpositions =
-                  if misspellings.is_a?(Hash) && misspellings.key?(:transpositions)
-                    {fuzzy_transpositions: misspellings[:transpositions]}
-                  elsif below14?
-                    {}
-                  else
-                    {fuzzy_transpositions: true}
-                  end
-                prefix_length = (misspellings.is_a?(Hash) && misspellings[:prefix_length]) || 0
-                max_expansions = (misspellings.is_a?(Hash) && misspellings[:max_expansions]) || 3
-              end
-
               if field == "_all" || field.end_with?(".analyzed")
                 shared_options[:cutoff_frequency] = 0.001 unless operator == "and" || misspellings == false
                 qs.concat [
@@ -436,10 +542,12 @@ module Searchkick
               payload[:highlight][:fields] = {}
 
               highlight_fields.each do |name, opts|
-                payload[:highlight][:fields]["#{name}.analyzed"] = opts || {}
+                payload[:highlight][:fields]["#{name}.#{@match_suffix}"] = opts || {}
               end
             end
           end
+
+          @highlighted_fields = payload[:highlight][:fields].keys
         end
 
         # An empty array will cause only the _id and _type for each hit to be returned
@@ -466,89 +574,6 @@ module Searchkick
       @load = load
     end
 
-    def searchkick_index
-      klass.searchkick_index
-    end
-
-    def searchkick_options
-      klass.searchkick_options
-    end
-
-    def searchkick_klass
-      klass.searchkick_klass
-    end
-
-    def params
-      params = {
-        index: options[:index_name] || searchkick_index.name,
-        body: body
-      }
-      params.merge!(type: @type) if @type
-      params.merge!(routing: @routing) if @routing
-      params
-    end
-
-    def execute
-      @execute ||= begin
-        begin
-          response = Searchkick.client.search(params)
-        rescue => e # TODO rescue type
-          status_code = e.message[1..3].to_i
-          if status_code == 404
-            raise MissingIndexError, "Index missing - run #{searchkick_klass.name}.reindex"
-          elsif status_code == 500 && (
-              e.message.include?("IllegalArgumentException[minimumSimilarity >= 1]") ||
-              e.message.include?("No query registered for [multi_match]") ||
-              e.message.include?("[match] query does not support [cutoff_frequency]]") ||
-              e.message.include?("No query registered for [function_score]]")
-            )
-
-            raise UnsupportedVersionError, "This version of Searchkick requires Elasticsearch 1.0 or greater"
-          elsif status_code == 400
-            if e.message.include?("[multi_match] analyzer [searchkick_search] not found")
-              raise InvalidQueryError, "Bad mapping - run #{searchkick_klass.name}.reindex"
-            else
-              raise InvalidQueryError, e.message
-            end
-          else
-            raise e
-          end
-        end
-
-        # apply facet limit in client due to
-        # https://github.com/elasticsearch/elasticsearch/issues/1305
-        @facet_limits.each do |field, limit|
-          field = field.to_s
-          facet = response["facets"][field]
-          response["facets"][field]["terms"] = facet["terms"].first(limit)
-          response["facets"][field]["other"] = facet["total"] - facet["terms"].sum { |term| term["count"] }
-        end
-
-        opts = {
-          page: @page,
-          per_page: @per_page,
-          padding: @padding,
-          load: @load,
-          includes: options[:include] || options[:includes],
-          json: !options[:json].nil?
-        }
-        Searchkick::Results.new(searchkick_klass, response, opts)
-      end
-    end
-
-    def to_curl
-      query = params
-      type = query[:type]
-      index = query[:index].is_a?(Array) ? query[:index].join(",") : query[:index]
-
-      # no easy way to tell which host the client will use
-      host = Searchkick.client.transport.hosts.first
-      credentials = (host[:user] || host[:password]) ? "#{host[:user]}:#{host[:password]}@" : nil
-      "curl #{host[:protocol]}://#{credentials}#{host[:host]}:#{host[:port]}/#{CGI.escape(index)}#{type ? "/#{type.map { |t| CGI.escape(t) }.join(',')}" : ''}/_search?pretty -d '#{query[:body].to_json}'"
-    end
-
-    private
-
     def where_filters(where)
       filters = []
       (where || {}).each do |field, value|

data/lib/searchkick/results.rb

@@ -42,6 +42,14 @@ module Searchkick
               else
                 hit.except("fields").merge(hit["fields"])
               end
+
+            if hit["highlight"]
+              highlight = Hash[hit["highlight"].map { |k, v| [base_field(k), v.first] }]
+              options[:highlighted_fields].map{ |k| base_field(k) }.each do |k|
+                result["highlighted_#{k}"] ||= (highlight[k] || result[k])
+              end
+            end
+
             result["id"] ||= result["_id"] # needed for legacy reasons
             Hashie::Mash.new(result)
           end
@@ -65,7 +73,7 @@ module Searchkick
       each_with_hit.map do |model, hit|
         details = {}
         if hit["highlight"]
-          details[:highlight] = Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.analyzed\z/, "")).to_sym, v.first] }]
+          details[:highlight] = Hash[hit["highlight"].map { |k, v| [(options[:json] ? k : k.sub(/\.#{@options[:match_suffix]}\z/, "")).to_sym, v.first] }]
         end
         [model, details]
       end
@@ -189,5 +197,9 @@ module Searchkick
         raise "Not sure how to load records"
       end
     end
+
+    def base_field(k)
+      k.sub(/\.(analyzed|word_start|word_middle|word_end|text_start|text_middle|text_end|exact)\z/, "")
+    end
   end
 end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "1.0.3"
+  VERSION = "1.1.0"
 end

data/test/ci/before_install.sh

@@ -1,5 +1,7 @@
 #!/usr/bin/env bash
 
+gem install bundler
+
 sudo apt-get purge elasticsearch
 wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-1.7.3.deb
 sudo dpkg -i elasticsearch-1.7.3.deb

data/test/highlight_test.rb

@@ -27,7 +27,8 @@ class HighlightTest < Minitest::Test
 
   def test_field_options
     store_names ["Two Door Cinema Club are a Northern Irish indie rock band"]
-    assert_equal "Two Door <em>Cinema</em> Club are", Product.search("cinema", fields: [:name], highlight: {fields: {name: {fragment_size: 20}}}).with_details.first[1][:highlight][:name]
+    fragment_size = ENV["MATCH"] == "word_start" ? 26 : 20
+    assert_equal "Two Door <em>Cinema</em> Club are", Product.search("cinema", fields: [:name], highlight: {fields: {name: {fragment_size: fragment_size}}}).with_details.first[1][:highlight][:name]
   end
 
   def test_multiple_words
@@ -36,6 +37,7 @@ class HighlightTest < Minitest::Test
   end
 
   def test_json
+    skip if ENV["MATCH"] == "word_start"
     store_names ["Two Door Cinema Club"]
     json = {
       query: {

data/test/match_test.rb

@@ -198,6 +198,13 @@ class MatchTest < Minitest::Test
     assert_search "almond", []
   end
 
+  def test_unsearchable_where
+    store [
+      {name: "Unsearchable", description: "Almond"}
+    ]
+    assert_search "*", ["Unsearchable"], where: {description: "Almond"}
+  end
+
   def test_emoji
     skip unless defined?(EmojiParser)
     store_names ["Banana"]

data/test/misspellings_test.rb

@@ -33,4 +33,14 @@ class MisspellingsTest < Minitest::Test
     ]
     assert_search "red blue", ["red", "blue", "cyan", "magenta"], operator: "or", fields: ["color"], misspellings: false
   end
+
+  def test_misspellings_below_unmet
+    store_names ["abc", "abd", "aee"]
+    assert_search "abc", ["abc", "abd"], misspellings: {below: 2}
+  end
+
+  def test_misspellings_below_met
+    store_names ["abc", "abd", "aee"]
+    assert_search "abc", ["abc"], misspellings: {below: 1}
+  end
 end

data/test/synonyms_test.rb

@@ -41,6 +41,11 @@ class SynonymsTest < Minitest::Test
     assert_search "scallions", ["Green Onions"]
   end
 
+  def test_word_start
+    store_names ["Clorox Bleach", "Kroger Bleach"]
+    assert_search "clorox", ["Clorox Bleach", "Kroger Bleach"], fields: [{name: :word_start}]
+  end
+
   def test_wordnet
     skip unless ENV["TEST_WORDNET"]
     store_names ["Creature", "Beast", "Dragon"], Animal

data/test/test_helper.rb

@@ -216,7 +216,9 @@ class Product
     word_middle: [:name],
     word_end: [:name],
     highlight: [:name],
-    unsearchable: [:description]
+    # unsearchable: [:description],
+    searchable: [:name, :color],
+    match: ENV["MATCH"] ? ENV["MATCH"].to_sym : nil
 
   attr_accessor :conversions, :user_ids, :aisle
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-28 00:00:00.000000000 Z
+date: 2015-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -174,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Searchkick learns what your users are looking for. As more people search,
@@ -216,3 +216,4 @@ test_files:
 - test/synonyms_test.rb
 - test/test_helper.rb
 - test/where_test.rb
+has_rdoc: