searchkick 0.7.8 → 0.7.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb8ada9111159102b2327b5344afe0876aac137d
-  data.tar.gz: 3e3e655a723d06f6b741b0938d3fde6d02d5c7ab
+  metadata.gz: e2bc8db79f3c60a5694ccd3400713d0dc8788ffd
+  data.tar.gz: 163dfde8a0f72d3f9584ad7e6f94b6370bafceb3
 SHA512:
-  metadata.gz: fdb99efc9149d644dd126456c9ab2e753a6f67a77feb90e07ad20dcbea75dd7152705136a2e30cfd0fd9e1a38a0ba35b1f05d0b8dd6c986ba248aa90a82126b2
-  data.tar.gz: 04a2c3229e5f40a866fa8cc2aed8832d361d680ef9a88fe75d1e3b8dc72875524961056f2f00bf2edd7bcd07989864118367547006198588b5f3af3e0e81ee96
+  metadata.gz: 83f9f13181e205843a72d3539b4ebba790c98f3abdbb9f1be1a3bfda539eb415304bd8e9eaf9acea062f64f6dbbc227db0892cd76623178d0ab20783119a91d4
+  data.tar.gz: 2123d48c3269eb517108f8864740bb2d1cfdc3e0130ed99c161a51d09d97f24799625fc83896912ce4351cfd678434665cefcf176935c2b08f5b5006a23d031a

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.7.9
+
+- Added `tokens` method
+- Added `json` option
+- Added exact matches
+- Added `prev_page` for Kaminari pagination
+- Added `import` option to reindex
+
 ## 0.7.8
 
 - Added `boost_by` and `boost_where` options

data/Gemfile

@@ -4,6 +4,6 @@ source 'https://rubygems.org'
 gemspec
 
 gem "sqlite3"
-gem "activerecord"
+gem "activerecord", ">= 3.1"
 # gem "activerecord", "~> 3.2.0"
 # gem "activerecord", "~> 3.1.0"

data/README.md

@@ -42,7 +42,13 @@ brew install elasticsearch
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem "searchkick"
+gem 'searchkick'
+```
+
+For Elasticsearch 1.2, use:
+
+```ruby
+gem 'searchkick', github: 'ankane/searchkick', branch: 'elasticsearch-1.2'
 ```
 
 For Elasticsearch 0.90, use version `0.6.3` and [this readme](https://github.com/ankane/searchkick/blob/v0.6.3/README.md).
@@ -70,6 +76,8 @@ products.each do |product|
 end
 ```
 
+Searchkick supports the complete [Elasticsearch Search API](http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-search.html). As your search becomes more advanced, we recommend you use the [Elasticsearch DSL](#advanced) for maximum flexibility.
+
 ### Queries
 
 Query like SQL
@@ -78,8 +86,6 @@ Query like SQL
 Product.search "2% Milk", where: {in_stock: true}, limit: 10, offset: 50
 ```
 
-**Note:** If you prefer the Elasticsearch DSL, see the [Advanced section](#advanced)
-
 Search specific fields
 
 ```ruby
@@ -128,16 +134,18 @@ Boost by the value of a field
 
 ```ruby
 boost_by: [:orders_count] # give popular documents a little boost
-boost_by: {orders_count: {factor: 10}}
+boost_by: {orders_count: {factor: 10}} # default factor is 1
 ```
 
 Boost matching documents
 
 ```ruby
-boost_where: {user_id: 1}
+boost_where: {user_id: 1} # default factor is 1000
 boost_where: {user_id: {value: 1, factor: 100}}
 ```
 
+[Conversions](#keep-getting-better) are also a great way to boost.
+
 ### Get Everything
 
 Use a `*` for the query.
@@ -204,6 +212,12 @@ To boost fields, use:
 fields: [{"name^2" => :word_start}] # better interface on the way
 ```
 
+### Exact Matches
+
+```ruby
+User.search "hi@searchkick.org", fields: [{email: :exact}]
+```
+
 ### Language
 
 Searchkick defaults to English for stemming.  To change this, use:
@@ -337,7 +351,7 @@ class Product < ActiveRecord::Base
   def search_data
     {
       name: name,
-      user_ids: orders.pluck(:user_id) # boost this product for these users
+      orderer_ids: orders.pluck(:user_id) # boost this product for these users
     }
   end
 
@@ -347,7 +361,7 @@ end
 Reindex and search with:
 
 ```ruby
-Product.search "milk", boost_where: {user_id: 8}
+Product.search "milk", boost_where: {orderer_ids: current_user.id}
 ```
 
 ### Autocomplete
@@ -557,6 +571,33 @@ Animal.search "*", type: [Dog, Cat] # just cats and dogs
 Dog.search "airbudd", suggest: true # suggestions for all animals
 ```
 
+## Debugging Queries
+
+See how Elasticsearch tokenizes your queries with:
+
+```ruby
+Product.searchkick_index.tokens("Dish Washer Soap", analyzer: "default_index")
+# ["dish", "dishwash", "washer", "washersoap", "soap"]
+
+Product.searchkick_index.tokens("dishwasher soap", analyzer: "searchkick_search")
+# ["dishwashersoap"] - no match
+
+Product.searchkick_index.tokens("dishwasher soap", analyzer: "searchkick_search2")
+# ["dishwash", "soap"] - match!!
+```
+
+Partial matches
+
+```ruby
+Product.searchkick_index.tokens("San Diego", analyzer: "searchkick_word_start_index")
+# ["s", "sa", "san", "d", "di", "die", "dieg", "diego"]
+
+Product.searchkick_index.tokens("dieg", analyzer: "searchkick_word_search")
+# ["dieg"] - match!!
+```
+
+See the [complete list of analyzers](lib/searchkick/reindex.rb#L86).
+
 ## Deployment
 
 Searchkick uses `ENV["ELASTICSEARCH_URL"]` for the Elasticsearch server.  This defaults to `http://localhost:9200`.

data/lib/searchkick/index.rb

@@ -65,6 +65,10 @@ module Searchkick
       end
     end
 
+    def tokens(text, options = {})
+      client.indices.analyze({text: text, index: name}.merge(options))["tokens"].map{|t| t["token"] }
+    end
+
     protected
 
     def client

data/lib/searchkick/query.rb

@@ -45,276 +45,286 @@ module Searchkick
       padding = [options[:padding].to_i, 0].max
       offset = options[:offset] || (page - 1) * per_page + padding
 
+      # model and eagar loading
+      load = options[:load].nil? ? true : options[:load]
+
       conversions_field = searchkick_options[:conversions]
       personalize_field = searchkick_options[:personalize]
 
       all = term == "*"
+      facet_limits = {}
 
-      if options[:query]
-        payload = options[:query]
-      elsif options[:similar]
-        payload = {
-          more_like_this: {
-            fields: fields,
-            like_text: term,
-            min_doc_freq: 1,
-            min_term_freq: 1,
-            analyzer: "searchkick_search2"
-          }
-        }
-      elsif all
-        payload = {
-          match_all: {}
-        }
+      if options[:json]
+        payload = options[:json]
       else
-        if options[:autocomplete]
+        if options[:query]
+          payload = options[:query]
+        elsif options[:similar]
           payload = {
-            multi_match: {
+            more_like_this: {
               fields: fields,
-              query: term,
-              analyzer: "searchkick_autocomplete_search"
+              like_text: term,
+              min_doc_freq: 1,
+              min_term_freq: 1,
+              analyzer: "searchkick_search2"
             }
           }
+        elsif all
+          payload = {
+            match_all: {}
+          }
         else
-          queries = []
-          fields.each do |field|
-            factor = boost_fields[field] || 1
-            shared_options = {
-              fields: [field],
-              query: term,
-              use_dis_max: false,
-              operator: operator,
-              boost: factor
+          if options[:autocomplete]
+            payload = {
+              multi_match: {
+                fields: fields,
+                query: term,
+                analyzer: "searchkick_autocomplete_search"
+              }
             }
-            if field == "_all" or field.end_with?(".analyzed")
-              shared_options[:cutoff_frequency] = 0.001 unless operator == "and"
-              queries.concat [
-                {multi_match: shared_options.merge(boost: 10 * factor, analyzer: "searchkick_search")},
-                {multi_match: shared_options.merge(boost: 10 * factor, analyzer: "searchkick_search2")}
-              ]
-              if options[:misspellings] != false
-                distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
-                queries.concat [
-                  {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search")},
-                  {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")}
+          else
+            queries = []
+            fields.each do |field|
+              qs = []
+
+              factor = boost_fields[field] || 1
+              shared_options = {
+                query: term,
+                operator: operator,
+                boost: factor
+              }
+
+              if field == "_all" or field.end_with?(".analyzed")
+                shared_options[:cutoff_frequency] = 0.001 unless operator == "and"
+                qs.concat [
+                  shared_options.merge(boost: 10 * factor, analyzer: "searchkick_search"),
+                  shared_options.merge(boost: 10 * factor, analyzer: "searchkick_search2")
                 ]
+                if options[:misspellings] != false
+                  distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
+                  qs.concat [
+                    shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search"),
+                    shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")
+                  ]
+                end
+              elsif field.end_with?(".exact")
+                f = field.split(".")[0..-2].join(".")
+                queries << {match: {f => shared_options.merge(analyzer: "keyword")}}
+              else
+                analyzer = field.match(/\.word_(start|middle|end)\z/) ? "searchkick_word_search" : "searchkick_autocomplete_search"
+                qs << shared_options.merge(analyzer: analyzer)
               end
-            else
-              analyzer = field.match(/\.word_(start|middle|end)\z/) ? "searchkick_word_search" : "searchkick_autocomplete_search"
-              queries << {multi_match: shared_options.merge(analyzer: analyzer)}
+
+              queries.concat(qs.map{|q| {match: {field => q}} })
             end
-          end
 
-          payload = {
-            dis_max: {
-              queries: queries
+            payload = {
+              dis_max: {
+                queries: queries
+              }
             }
-          }
-        end
+          end
 
-        if conversions_field and options[:conversions] != false
-          # wrap payload in a bool query
-          payload = {
-            bool: {
-              must: payload,
-              should: {
-                nested: {
-                  path: conversions_field,
-                  score_mode: "total",
-                  query: {
-                    function_score: {
-                      boost_mode: "replace",
-                      query: {
-                        match: {
-                          query: term
+          if conversions_field and options[:conversions] != false
+            # wrap payload in a bool query
+            payload = {
+              bool: {
+                must: payload,
+                should: {
+                  nested: {
+                    path: conversions_field,
+                    score_mode: "total",
+                    query: {
+                      function_score: {
+                        boost_mode: "replace",
+                        query: {
+                          match: {
+                            query: term
+                          }
+                        },
+                        script_score: {
+                          script: "doc['count'].value"
                         }
-                      },
-                      script_score: {
-                        script: "doc['count'].value"
                       }
                     }
                   }
                 }
               }
             }
-          }
+          end
         end
-      end
 
-      custom_filters = []
+        custom_filters = []
 
-      boost_by = options[:boost_by] || {}
-      if boost_by.is_a?(Array)
-        boost_by = Hash[ boost_by.map{|f| [f, {factor: 1}] } ]
-      end
-      if options[:boost]
-        boost_by[options[:boost]] = {factor: 1}
-      end
+        boost_by = options[:boost_by] || {}
+        if boost_by.is_a?(Array)
+          boost_by = Hash[ boost_by.map{|f| [f, {factor: 1}] } ]
+        end
+        if options[:boost]
+          boost_by[options[:boost]] = {factor: 1}
+        end
 
-      boost_by.each do |field, value|
-        custom_filters << {
-          filter: {
-            exists: {
-              field: field
+        boost_by.each do |field, value|
+          custom_filters << {
+            filter: {
+              exists: {
+                field: field
+              }
+            },
+            script_score: {
+              script: "#{value[:factor].to_f} * log(doc['#{field}'].value + 2.718281828)"
             }
-          },
-          script_score: {
-            script: "#{value[:factor].to_f} * log(doc['#{field}'].value + 2.718281828)"
           }
-        }
-      end
-
-      boost_where = options[:boost_where] || {}
-      if options[:user_id] and personalize_field
-        boost_where[personalize_field] = options[:user_id]
-      end
-      if options[:personalize]
-        boost_where.merge!(options[:personalize])
-      end
-      boost_where.each do |field, value|
-        if value.is_a?(Hash)
-          value, factor = value[:value], value[:factor]
-        else
-          factor = 1000
         end
-        custom_filters << {
-          filter: {
-            term: {field => value}
-          },
-          boost_factor: factor
-        }
-      end
 
-      if custom_filters.any?
-        payload = {
-          function_score: {
-            functions: custom_filters,
-            query: payload,
-            score_mode: "sum"
+        boost_where = options[:boost_where] || {}
+        if options[:user_id] and personalize_field
+          boost_where[personalize_field] = options[:user_id]
+        end
+        if options[:personalize]
+          boost_where.merge!(options[:personalize])
+        end
+        boost_where.each do |field, value|
+          if value.is_a?(Hash)
+            value, factor = value[:value], value[:factor]
+          else
+            factor = 1000
+          end
+          custom_filters << {
+            filter: {
+              term: {field => value}
+            },
+            boost_factor: factor
           }
-        }
-      end
-
-      payload = {
-        query: payload,
-        size: per_page,
-        from: offset
-      }
-      payload[:explain] = options[:explain] if options[:explain]
+        end
 
-      # order
-      if options[:order]
-        order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
-        payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
-      end
+        if custom_filters.any?
+          payload = {
+            function_score: {
+              functions: custom_filters,
+              query: payload,
+              score_mode: "sum"
+            }
+          }
+        end
 
-      # filters
-      filters = where_filters(options[:where])
-      if filters.any?
-        payload[:filter] = {
-          and: filters
+        payload = {
+          query: payload,
+          size: per_page,
+          from: offset
         }
-      end
+        payload[:explain] = options[:explain] if options[:explain]
 
-      # facets
-      facet_limits = {}
-      if options[:facets]
-        facets = options[:facets] || {}
-        if facets.is_a?(Array) # convert to more advanced syntax
-          facets = Hash[ facets.map{|f| [f, {}] } ]
+        # order
+        if options[:order]
+          order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
+          payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
         end
 
-        payload[:facets] = {}
-        facets.each do |field, facet_options|
-          # ask for extra facets due to
-          # https://github.com/elasticsearch/elasticsearch/issues/1305
-          size = facet_options[:limit] ? facet_options[:limit] + 150 : 100000
+        # filters
+        filters = where_filters(options[:where])
+        if filters.any?
+          payload[:filter] = {
+            and: filters
+          }
+        end
+
+        # facets
+        if options[:facets]
+          facets = options[:facets] || {}
+          if facets.is_a?(Array) # convert to more advanced syntax
+            facets = Hash[ facets.map{|f| [f, {}] } ]
+          end
+
+          payload[:facets] = {}
+          facets.each do |field, facet_options|
+            # ask for extra facets due to
+            # https://github.com/elasticsearch/elasticsearch/issues/1305
+            size = facet_options[:limit] ? facet_options[:limit] + 150 : 100000
 
-          if facet_options[:ranges]
-            payload[:facets][field] = {
-              range: {
-                field.to_sym => facet_options[:ranges]
+            if facet_options[:ranges]
+              payload[:facets][field] = {
+                range: {
+                  field.to_sym => facet_options[:ranges]
+                }
               }
-            }
-          elsif facet_options[:stats]
-            payload[:facets][field] = {
-              terms_stats: {
-                key_field: field,
-                value_script: "doc.score",
-                size: size
+            elsif facet_options[:stats]
+              payload[:facets][field] = {
+                terms_stats: {
+                  key_field: field,
+                  value_script: "doc.score",
+                  size: size
+                }
               }
-            }
-          else
-            payload[:facets][field] = {
-              terms: {
-                field: field,
-                size: size
+            else
+              payload[:facets][field] = {
+                terms: {
+                  field: field,
+                  size: size
+                }
               }
-            }
-          end
+            end
 
-          facet_limits[field] = facet_options[:limit] if facet_options[:limit]
+            facet_limits[field] = facet_options[:limit] if facet_options[:limit]
 
-          # offset is not possible
-          # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html
+            # offset is not possible
+            # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html
 
-          facet_options.deep_merge!(where: options[:where].reject{|k| k == field}) if options[:smart_facets] == true
-          facet_filters = where_filters(facet_options[:where])
-          if facet_filters.any?
-            payload[:facets][field][:facet_filter] = {
-              and: {
-                filters: facet_filters
+            facet_options.deep_merge!(where: options[:where].reject{|k| k == field}) if options[:smart_facets] == true
+            facet_filters = where_filters(facet_options[:where])
+            if facet_filters.any?
+              payload[:facets][field][:facet_filter] = {
+                and: {
+                  filters: facet_filters
+                }
               }
-            }
+            end
           end
         end
-      end
 
-      # suggestions
-      if options[:suggest]
-        suggest_fields = (searchkick_options[:suggest] || []).map(&:to_s)
+        # suggestions
+        if options[:suggest]
+          suggest_fields = (searchkick_options[:suggest] || []).map(&:to_s)
 
-        # intersection
-        if options[:fields]
-          suggest_fields = suggest_fields & options[:fields].map{|v| (v.is_a?(Hash) ? v.keys.first : v).to_s }
-        end
+          # intersection
+          if options[:fields]
+            suggest_fields = suggest_fields & options[:fields].map{|v| (v.is_a?(Hash) ? v.keys.first : v).to_s }
+          end
 
-        if suggest_fields.any?
-          payload[:suggest] = {text: term}
-          suggest_fields.each do |field|
-            payload[:suggest][field] = {
-              phrase: {
-                field: "#{field}.suggest"
+          if suggest_fields.any?
+            payload[:suggest] = {text: term}
+            suggest_fields.each do |field|
+              payload[:suggest][field] = {
+                phrase: {
+                  field: "#{field}.suggest"
+                }
               }
-            }
+            end
           end
         end
-      end
 
-      # highlight
-      if options[:highlight]
-        payload[:highlight] = {
-          fields: Hash[ fields.map{|f| [f, {}] } ]
-        }
-        if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
-          payload[:highlight][:pre_tags] = [tag]
-          payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
+        # highlight
+        if options[:highlight]
+          payload[:highlight] = {
+            fields: Hash[ fields.map{|f| [f, {}] } ]
+          }
+          if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
+            payload[:highlight][:pre_tags] = [tag]
+            payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
+          end
         end
-      end
 
-      # model and eagar loading
-      load = options[:load].nil? ? true : options[:load]
-
-      # An empty array will cause only the _id and _type for each hit to be returned
-      # http://www.elasticsearch.org/guide/reference/api/search/fields/
-      if load
-        payload[:fields] = []
-      elsif options[:select]
-        payload[:fields] = options[:select]
-      end
+        # An empty array will cause only the _id and _type for each hit to be returned
+        # http://www.elasticsearch.org/guide/reference/api/search/fields/
+        if load
+          payload[:fields] = []
+        elsif options[:select]
+          payload[:fields] = options[:select]
+        end
 
-      if options[:type] or klass != searchkick_klass
-        @type = [options[:type] || klass].flatten.map{|v| searchkick_index.klass_document_type(v) }
+        if options[:type] or klass != searchkick_klass
+          @type = [options[:type] || klass].flatten.map{|v| searchkick_index.klass_document_type(v) }
+        end
       end
 
       @body = payload
@@ -386,7 +396,8 @@ module Searchkick
         per_page: @per_page,
         padding: @padding,
         load: @load,
-        includes: options[:include] || options[:includes]
+        includes: options[:include] || options[:includes],
+        json: !options[:json].nil?
       }
       Searchkick::Results.new(searchkick_klass, response, opts)
     end

data/lib/searchkick/reindex.rb

@@ -3,7 +3,9 @@ module Searchkick
 
     # https://gist.github.com/jarosan/3124884
     # http://www.elasticsearch.org/blog/changing-mapping-with-zero-downtime/
-    def reindex
+    def reindex(options = {})
+      skip_import = options[:import] == false
+
       alias_name = searchkick_index.name
       new_name = alias_name + "_" + Time.now.strftime("%Y%m%d%H%M%S%L")
       index = Searchkick::Index.new(new_name)
@@ -14,7 +16,8 @@ module Searchkick
 
       # check if alias exists
       if Searchkick.client.indices.exists_alias(name: alias_name)
-        searchkick_import(index) # import before swap
+        # import before swap
+        searchkick_import(index) unless skip_import
 
         # get existing indices to remove
         old_indices = Searchkick.client.indices.get_alias(name: alias_name).keys
@@ -24,7 +27,9 @@ module Searchkick
       else
         searchkick_index.delete if searchkick_index.exists?
         Searchkick.client.indices.update_aliases body: {actions: [{add: {index: new_name, alias: alias_name}}]}
-        searchkick_import(index) # import after swap
+
+        # import after swap
+        searchkick_import(index) unless skip_import
       end
 
       index.refresh

data/lib/searchkick/results.rb

@@ -1,3 +1,5 @@
+require "forwardable"
+
 module Searchkick
   class Results
     include Enumerable
@@ -67,7 +69,7 @@ module Searchkick
       each_with_hit.map do |model, hit|
         details = {}
         if hit["highlight"]
-          details[:highlight] = Hash[ hit["highlight"].map{|k, v| [k.sub(/\.analyzed\z/, "").to_sym, v.first] } ]
+          details[:highlight] = Hash[ hit["highlight"].map{|k, v| [(options[:json] ? k : k.sub(/\.analyzed\z/, "")).to_sym, v.first] } ]
         end
         [model, details]
       end
@@ -112,6 +114,7 @@ module Searchkick
     def previous_page
       current_page > 1 ? (current_page - 1) : nil
     end
+    alias_method :prev_page, :previous_page
 
     def next_page
       current_page < total_pages ? (current_page + 1) : nil

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.7.8"
+  VERSION = "0.7.9"
 end

data/test/autocomplete_test.rb

@@ -57,4 +57,11 @@ class TestAutocomplete < Minitest::Unit::TestCase
     assert_search "dark grey", ["Dark Grey"], fields: [{name: :word_start}]
   end
 
+  # TODO find a better place
+
+  def test_exact
+    store_names ["hi@example.org"]
+    assert_search "hi@example.org", ["hi@example.org"], fields: [{name: :exact}]
+  end
+
 end

data/test/highlight_test.rb

@@ -19,4 +19,23 @@ class TestHighlight < Minitest::Unit::TestCase
     assert_equal "<em>Cinema</em> Orange", highlight[:color]
   end
 
+  def test_json
+    store_names ["Two Door Cinema Club"]
+    json = {
+      query: {
+        match: {
+          _all: "cinema"
+        }
+      },
+      highlight: {
+        pre_tags: ["<strong>"],
+        post_tags: ["</strong>"],
+        fields: {
+          "name.analyzed" => {}
+        }
+      }
+    }
+    assert_equal "Two Door <strong>Cinema</strong> Club", Product.search(json: json).with_details.first[1][:highlight][:"name.analyzed"]
+  end
+
 end

data/test/index_test.rb

@@ -35,6 +35,20 @@ class TestIndex < Minitest::Unit::TestCase
     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)
+  end
+
+  def test_tokens
+    assert_equal ["dollar", "dollartre", "tree"], Product.searchkick_index.tokens("Dollar Tree")
+  end
+
+  def test_tokens_analyzer
+    assert_equal ["dollar", "tree"], Product.searchkick_index.tokens("Dollar Tree", analyzer: "searchkick_search2")
+  end
+
   def test_record_not_found
     store_names ["Product A", "Product B"]
     Product.where(name: "Product A").delete_all

data/test/sql_test.rb

@@ -33,6 +33,9 @@ class TestSql < Minitest::Unit::TestCase
     assert_equal 2, products.limit_value
     assert_equal 3, products.offset_value
     assert_equal 3, products.offset
+    assert_equal 3, products.next_page
+    assert_equal 1, products.previous_page
+    assert_equal 1, products.prev_page
     assert !products.first_page?
     assert !products.last_page?
     assert !products.empty?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.7.8
+  version: 0.7.9
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-22 00:00:00.000000000 Z
+date: 2014-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel