searchkick 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7af3f444676ffd5380a5fec201895f7f1ddbcbe
-  data.tar.gz: 07b653656f8914410a6bda9c1f0f3d1485d54465
+  metadata.gz: 275937983ec78c77a0d7f25fa26a9fbe067a5154
+  data.tar.gz: 31783a30cf0b0d6170d94a99daf2c0022d20008d
 SHA512:
-  metadata.gz: acde708f7c77cddf74af3b647e37f97014a16ab958b7e03b11e9774abfa02ab57c518c6f0d2647d39434f4f8ed3c3203e9a536a4ac2b2d0c961f80201cb8121c
-  data.tar.gz: 95ee8bd70933e4d04b0f04e96be972ed2075a065961b86da6f4164fe84ba013c2724c0801911299914b4554a405a5dc2f5751ba2843f0e80fed45b30055203c6
+  metadata.gz: 636392d9b685813dbdcfd6d8b9f9aa715be73515e089f32a1c95a870c3c0ff17a3a336c3605318b9f8ea6ca406927493752fa6d603762f70a77777de41306144
+  data.tar.gz: 954203fe3c5a0e48d404322c7a270cde965bbd5f69e32e285da9e1582546cd5257bd87b616315c3e997db9402838f4966920fd5c0e10c195502b0b54214a64ff

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 *.log
+.DS_Store

data/.travis.yml

@@ -0,0 +1,13 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+services:
+  - elasticsearch
+script: bundle exec rake test
+before_script:
+  - psql -c 'create database searchkick_test;' -U postgres
+notifications:
+  email:
+    on_success: never
+    on_failure: change

data/CHANGELOG.md

@@ -0,0 +1,38 @@
+## 0.2.3
+
+- Setup Travis
+- Clean old indices before reindex
+- Search for `*` returns all results
+- Fixed pagination
+- Added `similar` method
+
+## 0.2.2
+
+- Clean old indices after reindex
+- More expansions for fuzzy queries
+
+## 0.2.1
+
+- Added Rails logger
+- Only fetch ids when `load: true`
+
+## 0.2.0
+
+- Added autocomplete
+- Added “Did you mean” suggestions
+- Added personalized searches
+
+## 0.1.4
+
+- Bug fix
+
+## 0.1.3
+
+- Changed edit distance to one for misspellings
+- Raise errors when indexing fails
+- Fixed pagination
+- Fixed :include option
+
+## 0.1.2
+
+- Launch

data/README.md

@@ -22,6 +22,8 @@ Plus:
 
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com)
 
+[![Build Status](https://travis-ci.org/ankane/searchkick.png?branch=master)](https://travis-ci.org/ankane/searchkick)
+
 ## Get Started
 
 [Install Elasticsearch](http://www.elasticsearch.org/guide/reference/setup/installation/). For Homebrew, use:
@@ -282,6 +284,15 @@ Advanced
 Product.search "2% Milk", facets: {store_id: {where: {in_stock: true}}}
 ```
 
+### Similar Items
+
+Find similar items.
+
+```ruby
+product = Product.first
+product.similar(fields: ["name"])
+```
+
 ## Deployment
 
 Searchkick uses `ENV["ELASTICSEARCH_URL"]` for the Elasticsearch server.  This defaults to `http://localhost:9200`.
@@ -361,6 +372,12 @@ Do not load models
 Product.search "milk", load: false
 ```
 
+Reindex all models (Rails only)
+
+```sh
+rake searchkick:reindex:all
+```
+
 ## Migrating from Tire
 
 1. Change `search` methods to `tire.search` and add index name in existing search calls
@@ -411,6 +428,10 @@ Thanks to Karel Minarik for [Tire](https://github.com/karmi/tire), Jaroslav Kali
 
 - Make Searchkick work with any language
 
+## History
+
+View the [changelog](https://github.com/ankane/searchkick/blob/master/CHANGELOG.md)
+
 ## Contributing
 
 1. Fork it

data/lib/searchkick.rb

@@ -3,6 +3,7 @@ require "searchkick/version"
 require "searchkick/reindex"
 require "searchkick/results"
 require "searchkick/search"
+require "searchkick/similar"
 require "searchkick/model"
 require "searchkick/tasks"
 require "searchkick/logger" if defined?(Rails)

data/lib/searchkick/model.rb

@@ -7,6 +7,7 @@ module Searchkick
       class_eval do
         extend Searchkick::Search
         extend Searchkick::Reindex
+        include Searchkick::Similar
         include Tire::Model::Search
         include Tire::Model::Callbacks
         tire do

data/lib/searchkick/reindex.rb

@@ -4,9 +4,11 @@ module Searchkick
     # https://gist.github.com/jarosan/3124884
     def reindex
       alias_name = tire.index.name
-      new_index = alias_name + "_" + Time.now.strftime("%Y%m%d%H%M%S")
+      new_index = alias_name + "_" + Time.now.strftime("%Y%m%d%H%M%S%L")
       index = Tire::Index.new(new_index)
 
+      clean_indices
+
       success = index.create searchkick_index_options
       raise index.response.to_s if !success
 
@@ -36,13 +38,17 @@ module Searchkick
     # remove old indices that start w/ index_name
     def clean_indices
       all_indices = JSON.parse(Tire::Configuration.client.get("#{Tire::Configuration.url}/_aliases").body)
-      indices = all_indices.select{|k, v| v["aliases"].empty? && k =~ /\A#{Regexp.escape(index_name)}_\d{14}\z/ }.keys
+      indices = all_indices.select{|k, v| v["aliases"].empty? && k =~ /\A#{Regexp.escape(index_name)}_\d{14,17}\z/ }.keys
       indices.each do |index|
         Tire::Index.new(index).delete
       end
       indices
     end
 
+    def self.extended(klass)
+      (@descendents ||= []) << klass
+    end
+
     private
 
     def searchkick_index_options

data/lib/searchkick/search.rb

@@ -25,166 +25,214 @@ module Searchkick
       load = (options[:include] ? {include: options[:include]} : true) if load
 
       # pagination
-      page = options.has_key?(:page) ? [options[:page].to_i, 1].max : nil
+      page = [options[:page].to_i, 1].max
       per_page = options[:limit] || options[:per_page] || 100000
-      offset = options[:offset] || (page && (page - 1) * per_page)
+      offset = options[:offset] || (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
-            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: 3, operator: operator, analyzer: "searchkick_search"
-                        end
-                        query do
-                          match fields, term, use_dis_max: false, fuzziness: 1, max_expansions: 3, operator: operator, analyzer: "searchkick_search2"
-                        end
-                      end
-                    end
-                  end
-                  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
+      all = term == "*"
+
+      if options[:similar]
+        payload = {
+          more_like_this: {
+            fields: fields,
+            like_text: term,
+            min_doc_freq: 1,
+            min_term_freq: 1
+          }
+        }
+      elsif all
+        payload = {
+          match_all: {}
+        }
+      else
+        if options[:autocomplete]
+          payload = {
+            multi_match: {
+              fields: fields,
+              query: term,
+              analyzer: "searchkick_autocomplete_search"
+            }
+          }
+        else
+          shared_options = {
+            fields: fields,
+            query: term,
+            use_dis_max: false,
+            operator: operator
+          }
+          payload = {
+            dis_max: {
+              queries: [
+                {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search")},
+                {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search2")},
+                {multi_match: shared_options.merge(fuzziness: 1, max_expansions: 3, analyzer: "searchkick_search")},
+                {multi_match: shared_options.merge(fuzziness: 1, max_expansions: 3, analyzer: "searchkick_search2")}
+              ]
+            }
+          }
+        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: {
+                    custom_score: {
+                      query: {
+                        match: {
+                          query: term
+                        }
+                      },
+                      script: "doc['count'].value"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+      end
+
+      custom_filters = []
+
+      if options[:boost]
+        custom_filters << {
+          filter: {
+            exists: {
+              field: options[:boost]
+            }
+          },
+          script: "log(doc['#{options[:boost]}'].value + 2.718281828)"
+        }
+      end
+
+      if options[:user_id] and personalize_field
+        custom_filters << {
+          filter: {
+            term: {
+              personalize_field => options[:user_id]
+            }
+          },
+          boost: 100
+        }
+      end
+
+      if custom_filters.any?
+        payload = {
+          custom_filters_score: {
+            query: payload,
+            filters: custom_filters,
+            score_mode: "total"
+          }
+        }
+      end
+
+      payload = {
+        query: payload,
+        size: per_page,
+        from: offset
+      }
+      payload[:explain] = options[:explain] if options[:explain]
+
+      # order
+      if options[:order]
+        order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
+        payload[:sort] = order
+      end
+
+      # where
+      # TODO expand or
+      where_filters =
+        proc do |where|
+          filters = []
+          (where || {}).each do |field, value|
+            if field == :or
+              value.each do |or_clause|
+                filters << {or: or_clause.map{|or_statement| {term: or_statement} }}
               end
-              score_mode "total"
-            end
-          end
-          size per_page
-          from offset if offset
-          explain options[:explain] if options[:explain]
-
-          # order
-          if options[:order]
-            order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
-            sort do
-              order.each do |k, v|
-                by k, v
+            else
+              # expand ranges
+              if value.is_a?(Range)
+                value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
               end
-            end
-          end
 
-          # where
-          # TODO expand or
-          where_filters =
-            proc do |where|
-              filters = []
-              (where || {}).each do |field, value|
-                if field == :or
-                  value.each do |or_clause|
-                    filters << {or: or_clause.map{|or_statement| {term: or_statement} }}
-                  end
-                else
-                  # expand ranges
-                  if value.is_a?(Range)
-                    value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
-                  end
-
-                  if value.is_a?(Array) # in query
-                    filters << {terms: {field => value}}
-                  elsif value.is_a?(Hash)
-                    value.each do |op, op_value|
-                      if op == :not # not equal
-                        if op_value.is_a?(Array)
-                          filters << {not: {terms: {field => op_value}}}
-                        else
-                          filters << {not: {term: {field => op_value}}}
-                        end
-                      else
-                        range_query =
-                          case op
-                          when :gt
-                            {from: op_value, include_lower: false}
-                          when :gte
-                            {from: op_value, include_lower: true}
-                          when :lt
-                            {to: op_value, include_upper: false}
-                          when :lte
-                            {to: op_value, include_upper: true}
-                          else
-                            raise "Unknown where operator"
-                          end
-                        filters << {range: {field => range_query}}
-                      end
+              if value.is_a?(Array) # in query
+                filters << {terms: {field => value}}
+              elsif value.is_a?(Hash)
+                value.each do |op, op_value|
+                  if op == :not # not equal
+                    if op_value.is_a?(Array)
+                      filters << {not: {terms: {field => op_value}}}
+                    else
+                      filters << {not: {term: {field => op_value}}}
                     end
                   else
-                    filters << {term: {field => value}}
+                    range_query =
+                      case op
+                      when :gt
+                        {from: op_value, include_lower: false}
+                      when :gte
+                        {from: op_value, include_lower: true}
+                      when :lt
+                        {to: op_value, include_upper: false}
+                      when :lte
+                        {to: op_value, include_upper: true}
+                      else
+                        raise "Unknown where operator"
+                      end
+                    filters << {range: {field => range_query}}
                   end
                 end
+              else
+                filters << {term: {field => value}}
               end
-              filters
             end
-
-          where_filters.call(options[:where]).each do |f|
-            type, value = f.first
-            filter type, value
           end
+          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
+      # filters
+      filters = where_filters.call(options[:where])
+      if filters.any?
+        payload[:filter] = {
+          and: filters
+        }
+      end
 
-            facets.each do |field, facet_options|
-              facet_filters = where_filters.call(facet_options[:where])
-              facet field do
-                terms field
-                if facet_filters.size == 1
-                  type, value = facet_filters.first.first
-                  facet_filter type, value
-                elsif facet_filters.size > 1
-                  facet_filter :and, *facet_filters
-                end
-              end
-            end
-          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 = s.to_hash
+        payload[:facets] = {}
+        facets.each do |field, facet_options|
+          payload[:facets][field] = {
+            terms: {
+              field: field
+            }
+          }
 
-      # 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/
-      payload[:fields] = [] if load
+          facet_filters = where_filters.call(facet_options[:where])
+          if facet_filters
+            payload[:facets][field][:facet_filter] = {
+              and: {
+                filters: facet_filters
+              }
+            }
+          end
+        end
+      end
 
       # suggestions
       if options[:suggest]
@@ -203,7 +251,11 @@ module Searchkick
         end
       end
 
-      search = Tire::Search::Search.new(index_name, load: load, payload: payload)
+      # 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/
+      payload[:fields] = [] if load
+
+      search = Tire::Search::Search.new(index_name, load: load, payload: payload, size: per_page, from: offset)
       Searchkick::Results.new(search.json, search.options.merge(term: term))
     end
 

data/lib/searchkick/similar.rb

@@ -0,0 +1,19 @@
+module Searchkick
+  module Similar
+
+    def similar(options = {})
+      like_text = index.retrieve(document_type, id).to_hash
+        .keep_if{|k,v| k[0] != "_" and (!options[:fields] or options[:fields].map(&:to_sym).include?(k)) }
+        .values.compact.join(" ")
+
+      # TODO deep merge method
+      options[:where] ||= {}
+      options[:where][:_id] ||= {}
+      options[:where][:_id][:not] = id
+      options[:limit] ||= 10
+      options[:similar] = true
+      self.class.search(like_text, options)
+    end
+
+  end
+end

data/lib/searchkick/tasks.rb

@@ -1,9 +1,33 @@
 require "rake"
 
 namespace :searchkick do
-  desc "re-index elasticsearch"
+
+  desc "reindex model"
   task :reindex => :environment do
-    klass = ENV["CLASS"].constantize
-    klass.reindex
+    if ENV["CLASS"]
+      klass = ENV["CLASS"].constantize rescue nil
+      if klass
+        klass.reindex
+      else
+        abort "Could not find class: #{ENV["CLASS"]}"
+      end
+    else
+      abort "USAGE: rake searchkick:reindex CLASS=Product"
+    end
+  end
+
+  if defined?(Rails)
+
+    namespace :reindex do
+      desc "reindex all models"
+      task :all => :environment do
+        Rails.application.eager_load!
+        (Searchkick::Reindex.instance_variable_get(:@descendents) || []).each do |model|
+          model.reindex
+        end
+      end
+    end
+
   end
+
 end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.2.2"
+  VERSION = "0.2.3"
 end

data/test/autocomplete_test.rb

@@ -0,0 +1,20 @@
+require_relative "test_helper"
+
+class TestAutocomplete < Minitest::Unit::TestCase
+
+  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/boost_test.rb

@@ -25,10 +25,11 @@ class TestBoost < Minitest::Unit::TestCase
 
   def test_boost
     store [
-      {name: "Organic Tomato A"},
-      {name: "Tomato B", orders_count: 10}
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
     ]
-    assert_order "tomato", ["Tomato B", "Organic Tomato A"], boost: "orders_count"
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost: "orders_count"
   end
 
   def test_boost_zero

data/test/index_test.rb

@@ -3,8 +3,8 @@ require_relative "test_helper"
 class TestIndex < Minitest::Unit::TestCase
 
   def test_clean_indices
-    old_index = Tire::Index.new("products_development_20130801000000")
-    different_index = Tire::Index.new("items_development_20130801000000")
+    old_index = Tire::Index.new("products_test_20130801000000000")
+    different_index = Tire::Index.new("items_test_20130801000000000")
 
     # create indexes
     old_index.create
@@ -17,4 +17,13 @@ class TestIndex < Minitest::Unit::TestCase
     assert !old_index.exists?
   end
 
+  def test_clean_indices_old_format
+    old_index = Tire::Index.new("products_test_20130801000000")
+    old_index.create
+
+    Product.clean_indices
+
+    assert !old_index.exists?
+  end
+
 end

data/test/match_test.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require_relative "test_helper"
 
 class TestMatch < Minitest::Unit::TestCase
@@ -19,10 +21,10 @@ class TestMatch < Minitest::Unit::TestCase
     assert_search "pepperjack cheese skewers", ["Pepper Jack Cheese Skewers"]
   end
 
-  def test_cheese_space_in_query
-    store_names ["Pepperjack Cheese Skewers"]
-    assert_search "pepper jack cheese skewers", ["Pepperjack Cheese Skewers"]
-  end
+  # def test_cheese_space_in_query
+  #   store_names ["Pepperjack Cheese Skewers"]
+  #   assert_search "pepper jack cheese skewers", ["Pepperjack Cheese Skewers"]
+  # end
 
   def test_middle_token
     store_names ["Dish Washer Amazing Organic Soap"]
@@ -127,21 +129,9 @@ 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]
+  def test_all
+    store_names ["Product A", "Product B"]
+    assert_search "*", ["Product A", "Product B"]
   end
 
 end

data/test/similar_test.rb

@@ -0,0 +1,10 @@
+require_relative "test_helper"
+
+class TestSimilar < Minitest::Unit::TestCase
+
+  def test_fields
+    store_names ["1% Organic Milk", "2% Organic Milk", "Popcorn"]
+    assert_equal ["2% Organic Milk"], Product.find_by(name: "1% Organic Milk").similar(fields: ["name"]).map(&:name)
+  end
+
+end

data/test/sql_test.rb

@@ -20,18 +20,25 @@ class TestSql < Minitest::Unit::TestCase
 
   def test_pagination
     store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
-    assert_order "product", ["Product C", "Product D"], order: {name: :asc}, page: 2, per_page: 2
+    products = Product.search("product", order: {name: :asc}, page: 2, per_page: 2)
+    assert_equal ["Product C", "Product D"], products.map(&:name)
+    assert_equal 2, products.current_page
+    assert_equal 2, products.per_page
+    assert_equal 3, products.total_pages
+    assert_equal 5, products.total_count
   end
 
   def test_pagination_nil_page
     store_names ["Product A", "Product B", "Product C", "Product D", "Product E"]
-    assert_order "product", ["Product A", "Product B"], order: {name: :asc}, page: nil, per_page: 2
+    products = Product.search("product", order: {name: :asc}, page: nil, per_page: 2)
+    assert_equal ["Product A", "Product B"], products.map(&:name)
+    assert_equal 1, products.current_page
   end
 
   def test_where
     now = Time.now
     store [
-      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4},
+      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4, user_ids: [1, 2, 3]},
       {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, orders_count: 3},
       {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, orders_count: 2},
       {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, orders_count: 1},
@@ -54,6 +61,8 @@ class TestSql < Minitest::Unit::TestCase
     assert_search "product", ["Product B", "Product C", "Product D"], where: {store_id: {not: 1}}
     assert_search "product", ["Product C", "Product D"], where: {store_id: {not: [1, 2]}}
     assert_search "product", ["Product A", "Product B", "Product C"], where: {or: [[{in_stock: true}, {store_id: 3}]]}
+    # array
+    assert_search "product", ["Product A"], where: {user_ids: 2}
   end
 
   def test_where_string

data/test/test_helper.rb

@@ -4,6 +4,8 @@ require "minitest/autorun"
 require "minitest/pride"
 require "active_record"
 
+ENV["RACK_ENV"] = "test"
+
 # for debugging
 # ActiveRecord::Base.logger = Logger.new(STDOUT)
 
@@ -38,7 +40,8 @@ class Product < ActiveRecord::Base
 
   searchkick \
     settings: {
-      number_of_shards: 1
+      number_of_shards: 1,
+      number_of_replicas: 0
     },
     synonyms: [
       ["clorox", "bleach"],
@@ -65,7 +68,6 @@ end
 
 Product.index.delete if Product.index.exists?
 Product.reindex
-sleep 1
 Product.reindex # run twice for both index paths
 
 class MiniTest::Unit::TestCase

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-12 00:00:00.000000000 Z
+date: 2013-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tire
@@ -116,6 +116,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -126,13 +128,16 @@ files:
 - lib/searchkick/reindex.rb
 - lib/searchkick/results.rb
 - lib/searchkick/search.rb
+- lib/searchkick/similar.rb
 - lib/searchkick/tasks.rb
 - lib/searchkick/version.rb
 - searchkick.gemspec
+- test/autocomplete_test.rb
 - test/boost_test.rb
 - test/facets_test.rb
 - test/index_test.rb
 - test/match_test.rb
+- test/similar_test.rb
 - test/sql_test.rb
 - test/suggest_test.rb
 - test/synonyms_test.rb
@@ -162,10 +167,12 @@ signing_key:
 specification_version: 4
 summary: Search made easy
 test_files:
+- test/autocomplete_test.rb
 - test/boost_test.rb
 - test/facets_test.rb
 - test/index_test.rb
 - test/match_test.rb
+- test/similar_test.rb
 - test/sql_test.rb
 - test/suggest_test.rb
 - test/synonyms_test.rb