searchkick 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f37d2d366a7f03a6e2757c688385aed25678836c
-  data.tar.gz: e4648bd3692a88ccd7d9669376f8fa89af8e7431
+  metadata.gz: edbfa8b338d8ddc3b4bcef4755151c98c7afeb30
+  data.tar.gz: aa1e1fbda8e995dfeb22cb005b5fc755020980bf
 SHA512:
-  metadata.gz: 071e83eab034feb8784f32791728fee4cb61e3670ef9f36f97ad66961e7c12c299214e44bde1c5aec45f56b92a5d639591e2f9845a3fd2a1c8aee9e3fb14c7a9
-  data.tar.gz: e42658adc41be4c3e2232bfa510f9e2026da8c6a1303b192e5f03692d9c0d15068e3d92252955bba136bea21bfe830674ae84251e7134dc280f642d7b7f9bea6
+  metadata.gz: 531313b35dae913d8d999fe3283c2a2535ada666c58c567cc385ac6574dbec0015bf65f2dbacdc1ac07b18eaca31d40aa776d968d1cb36db16f06dc34de633af
+  data.tar.gz: c3bd0aaee05a28b95d2884104144bc7058f26bd3b2c5eba75c68b02022c203bd3326fdfe99702139d264d386f92879467afb69f783a354662f188ead85788086

data/README.md

@@ -2,19 +2,39 @@
 
 :rocket: Search made easy
 
-Searchkick provides sensible search defaults out of the box.  It handles:
+Searchkick provides sensible search defaults.  It handles:
 
 - stemming - `tomatoes` matches `tomato`
-- special characters - `jalapenos` matches `jalapeños`
+- special characters - `jalapeno` matches `jalapeño`
 - extra whitespace - `dishwasher` matches `dish washer`
 - misspellings - `zuchini` matches `zucchini`
 - custom synonyms - `qtip` matches `cotton swab`
 
-Runs on Elasticsearch
+Plus:
+
+- query like SQL - no need to learn a new query language
+- reindex without downtime
+- continually improve results from conversions - **pretty awesome**
+
+Powered by Elasticsearch
 
 :tangerine: Battle-tested at [Instacart](https://www.instacart.com)
 
-## Usage
+## Get Started
+
+[Install Elasticsearch](http://www.elasticsearch.org/guide/reference/setup/installation/). For Homebrew, use:
+
+```sh
+brew install elasticsearch
+```
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem "searchkick"
+```
+
+Add searchkick to models you want to search.
 
 ```ruby
 class Product < ActiveRecord::Base
@@ -22,25 +42,37 @@ class Product < ActiveRecord::Base
 end
 ```
 
-And to query, use:
+Add data to the search index.
 
 ```ruby
-Product.search "2% Milk"
+Product.reindex
 ```
 
-or only search specific fields:
+And to query, use:
 
 ```ruby
-Product.search "Butter", fields: [:name, :brand]
+products = Product.search "2% Milk"
+products.each do |product|
+  puts product.name
+  puts product._score # added by searchkick - between 0 and 1
+end
 ```
 
-### Query Like SQL
+### Queries
+
+Query like SQL
 
 ```ruby
 Product.search "2% Milk", where: {in_stock: true}, limit: 10, offset: 50
 ```
 
-#### Where
+Search specific fields
+
+```ruby
+fields: [:name, :brand]
+```
+
+Where
 
 ```ruby
 where: {
@@ -55,28 +87,48 @@ where: {
 }
 ```
 
-#### Order
+Order
 
 ```ruby
 order: {_score: :desc} # most relevant first - default
 ```
 
-#### Explain
+Limit / offset
 
 ```ruby
-explain: true
+limit: 20, offset: 40
 ```
 
-### Facets
+Boost by a field
 
 ```ruby
-Product.search "2% Milk", facets: [:store_id, :aisle_id]
+boost: "orders_count" # give popular documents a little boost
 ```
 
-Advanced
+### Pagination
+
+Plays nicely with kaminari and will_paginate.
 
 ```ruby
-Product.search "2% Milk", facets: {store_id: {where: {in_stock: true}}}
+# controller
+@products = Product.search "milk", page: params[:page], per_page: 20
+
+# view
+<%= paginate @products %>
+```
+
+### Partial Matches
+
+By default, results must match all words in the query.
+
+```ruby
+Product.search "fresh honey" # fresh AND honey
+```
+
+To change this, use:
+
+```ruby
+Product.search "fresh honey", partial: true # fresh OR honey
 ```
 
 ### Synonyms
@@ -89,11 +141,39 @@ end
 
 You must call `Product.reindex` after changing synonyms.
 
-### Make Searches Better Over Time
+### Indexing
+
+Choose what data is indexed.
+
+```ruby
+class Product < ActiveRecord::Base
+  def _source
+    as_json only: [:name, :active], include: {brand: {only: [:city]}}
+    # or equivalently
+    {
+      name: name,
+      active: active,
+      brand: {
+        city: brand.city
+      }
+    }
+  end
+end
+```
+
+Searchkick uses `find_in_batches` to import documents.  To eager load associations, use the `searchkick_import` scope.
+
+```ruby
+class Product < ActiveRecord::Base
+  scope :searchkick_import, includes(:searches)
+end
+```
+
+### Continually Improve Results
 
-Improve results with analytics on conversions and give popular documents a little boost.
+Use data on search conversions to improve results.  This can make a **huge** difference.
 
-First, you must keep track of search conversions.  The database works well for low volume, but feel free to use redis or another datastore.
+First, keep track of conversions.  The database works well for low volume, but feel free to use Redis or another datastore.
 
 ```ruby
 class Search < ActiveRecord::Base
@@ -102,101 +182,138 @@ class Search < ActiveRecord::Base
 end
 ```
 
-Add the conversions to the index.
+Add conversions to the index.
 
 ```ruby
 class Product < ActiveRecord::Base
   has_many :searches
 
-  searchkick conversions: true
-
-  def to_indexed_json
+  def _source
     {
       name: name,
-      conversions: searches.group("query").count.map{|query, count| {query: query, count: count} }, # TODO fix
-      _boost: Math.log(orders_count) # boost more popular products a bit
+      conversions: searches.group("query").count
     }
   end
 end
 ```
 
-After the reindex is complete (to prevent errors), tell the search method to use conversions.
+Reindex and tell the search method to use conversions.
 
 ```ruby
 Product.search "Fat Free Milk", conversions: true
 ```
 
-### Zero Downtime Changes
+### Facets
 
 ```ruby
-Product.reindex
+search = Product.search "2% Milk", facets: [:store_id, :aisle_id]
+p search.facets
+```
+
+Advanced
+
+```ruby
+Product.search "2% Milk", facets: {store_id: {where: {in_stock: true}}}
 ```
 
-Behind the scenes, this creates a new index `products_20130714181054` and points the `products` alias to the new index when complete - an atomic operation :)
+## Deployment
+
+### Bonsai on Heroku
+
+Install the add-on:
+
+```sh
+heroku addons:add bonsai
+```
 
-Searchkick uses `find_in_batches` to import documents.  To filter documents or eagar load associations, use the `searchkick_import` scope.
+And create an initializer `config/initializers/bonsai.rb` with:
 
 ```ruby
-class Product < ActiveRecord::Base
-  scope :searchkick_import, where(active: true).includes(:searches)
-end
+ENV["ELASTICSEARCH_URL"] = ENV["BONSAI_URL"]
 ```
 
-There is also a rake task.
+Then deploy and reindex:
 
 ```sh
-rake searchkick:reindex CLASS=Product
+heroku run rake searchkick:reindex CLASS=Product
 ```
 
-Thanks to Jaroslav Kalistsuk for the [original implementation](https://gist.github.com/jarosan/3124884).
+## Reference
 
-### Reference
+Reindex one record
+
+```ruby
+product = Product.find 10
+product.reindex
+```
 
-Reindex one item
+Use a different index name
 
 ```ruby
-product = Product.find(1)
-product.update_index
+class Product < ActiveRecord::Base
+  searchkick index_name: "products_v2"
+end
 ```
 
-Partial matches (needs better name)
+Eagar load associations
 
 ```ruby
-Item.search "fresh honey", partial: true # matches organic honey
+Product.search "milk", include: [:brand, :stores]
 ```
 
-## Elasticsearch Gotchas
+Do not load models
 
-### Inconsistent Scores
+```ruby
+Product.search "milk", load: false
+```
+
+## Migrating from Tire
+
+1. Change `search` methods to `tire.search` and add index name in existing search calls
+
+  ```ruby
+  Product.search "fruit"
+  ```
+
+  should be replaced with
+
+  ```ruby
+  Product.tire.search "fruit", index: "products"
+  ```
+
+2. Replace tire mapping w/ searchkick method
 
-Due to the distributed nature of Elasticsearch, you can get incorrect results when the number of documents in the index is low.  You can [read more about it here](http://www.elasticsearch.org/blog/understanding-query-then-fetch-vs-dfs-query-then-fetch/).  To fix this, set the search type to `dfs_query_and_fetch`.  Alternatively, you can just use one shard with `settings: {number_of_shards: 1}`.
+  ```ruby
+  searchkick index_name: "products_v2"
+  ```
 
-## Installation
+3. Deploy and reindex
 
-Add this line to your application's Gemfile:
+  ```ruby
+  rake searchkick:reindex CLASS=Product # or Product.reindex in the console
+  ```
+
+4. Once it finishes, replace search calls w/ searchkick calls
+
+## Elasticsearch Gotchas
+
+### Inconsistent Scores
+
+Due to the distributed nature of Elasticsearch, you can get incorrect results when the number of documents in the index is low.  You can [read more about it here](http://www.elasticsearch.org/blog/understanding-query-then-fetch-vs-dfs-query-then-fetch/).  To fix this, do:
 
 ```ruby
-gem "searchkick"
+class Product < ActiveRecord::Base
+  searchkick settings: {number_of_shards: 1}
+end
 ```
 
-And then execute:
+## Thanks
 
-```sh
-bundle
-```
+Thanks to [Karel Minarik](https://github.com/karmi) for Tire and [Jaroslav Kalistsuk](https://github.com/jarosan) for zero downtime reindexing.
 
 ## TODO
 
-- Autocomplete
-- Option to turn off fuzzy matching (should this be default?)
-- Exact phrase matches (in order)
-- Focus on results format (load: true?)
-- Test helpers - everyone should test their own search
 - Built-in synonyms from WordNet
-- Dashboard w/ real-time analytics?
-- [Suggest API](http://www.elasticsearch.org/guide/reference/api/search/suggest/) "Did you mean?"
-- Allow for "exact search" with quotes
-- Make updates to old and new index while reindexing [possibly with an another alias](http://www.kickstarter.com/backing-and-hacking)
 
 ## Contributing
 

data/lib/searchkick.rb

@@ -4,6 +4,7 @@ require "searchkick/search"
 require "searchkick/model"
 require "searchkick/tasks"
 require "tire"
-require "active_record" # TODO only require active_model
 
-ActiveRecord::Base.send(:extend, Searchkick::Model)
+# TODO find better ActiveModel hook
+ActiveModel::AttributeMethods::ClassMethods.send(:include, Searchkick::Model)
+ActiveRecord::Base.send(:extend, Searchkick::Model) if defined?(ActiveRecord)

data/lib/searchkick/model.rb

@@ -2,79 +2,36 @@ module Searchkick
   module Model
 
     def searchkick(options = {})
-      custom_settings = {
-        analysis: {
-          analyzer: {
-            searchkick_keyword: {
-              type: "custom",
-              tokenizer: "keyword",
-              filter: ["lowercase", "snowball"]
-            },
-            default_index: {
-              type: "custom",
-              tokenizer: "standard",
-              # synonym should come last, after stemming and shingle
-              # shingle must come before snowball
-              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_index_shingle"]
-            },
-            searchkick_search: {
-              type: "custom",
-              tokenizer: "standard",
-              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_search_shingle"]
-            },
-            searchkick_search2: {
-              type: "custom",
-              tokenizer: "standard",
-              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball"] #, "searchkick_search_shingle"]
-            }
-          },
-          filter: {
-            searchkick_index_shingle: {
-              type: "shingle",
-              token_separator: ""
-            },
-            # lucky find http://web.archiveorange.com/archive/v/AAfXfQ17f57FcRINsof7
-            searchkick_search_shingle: {
-              type: "shingle",
-              token_separator: "",
-              output_unigrams: false,
-              output_unigrams_if_no_shingles: true
-            }
-          }
-        }
-      }.merge(options[:settings] || {})
-      synonyms = options[:synonyms] || []
-      if synonyms.any?
-        custom_settings[:analysis][:filter][:searchkick_synonym] = {
-          type: "synonym",
-          ignore_case: true,
-          synonyms: synonyms.map{|s| s.join(" => ") } # TODO support more than 2 synonyms on a line
-        }
-        custom_settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_synonym"
-        custom_settings[:analysis][:analyzer][:searchkick_search][:filter].insert(-2, "searchkick_synonym")
-        custom_settings[:analysis][:analyzer][:searchkick_search][:filter] << "searchkick_synonym"
-        custom_settings[:analysis][:analyzer][:searchkick_search2][:filter] << "searchkick_synonym"
-      end
+      @searchkick_options = options.dup
+      @searchkick_options[:conversions] = true if options[:conversions].nil?
 
       class_eval do
         extend Searchkick::Search
         extend Searchkick::Reindex
         include Tire::Model::Search
         include Tire::Model::Callbacks
-
         tire do
-          settings custom_settings
-          mapping do
-            # indexes field, analyzer: "searchkick"
-            if options[:conversions]
-              indexes :conversions, type: "nested" do
-                indexes :query, analyzer: "searchkick_keyword"
-                indexes :count, type: "integer"
-              end
-            end
+          index_name options[:index_name] || [klass.model_name.plural, ENV["RACK_ENV"] || "development"].join("_")
+        end
+        attr_accessor :_score
+
+        def reindex
+          update_index
+        end
+
+        def _source
+          as_json
+        end
+
+        def to_indexed_json
+          source = _source
+          if self.class.instance_variable_get("@searchkick_options")[:conversions] and source[:conversions]
+            source[:conversions] = source[:conversions].map{|k, v| {query: k, count: v} }
           end
+          source.to_json
         end
       end
     end
+
   end
 end

data/lib/searchkick/reindex.rb

@@ -5,17 +5,18 @@ module Searchkick
     def reindex
       alias_name = tire.index.name
       new_index = alias_name + "_" + Time.now.strftime("%Y%m%d%H%M%S")
-
-      # Rake::Task["tire:import"].invoke
       index = Tire::Index.new(new_index)
-      Tire::Tasks::Import.create_index(index, self) # TODO remove puts
+
+      index.create searchkick_index_options
+
+      # use scope for import
       scope = respond_to?(:searchkick_import) ? searchkick_import : self
       scope.find_in_batches do |batch|
         index.import batch
       end
 
       if a = Tire::Alias.find(alias_name)
-        old_indices = Tire::Alias.find(alias_name).indices
+        old_indices = a.indices.dup
         old_indices.each do |index|
           a.indices.delete index
         end
@@ -25,7 +26,7 @@ module Searchkick
 
         old_indices.each do |index|
           i = Tire::Index.new(index)
-          i.delete if i.exists?
+          i.delete
         end
       else
         i = Tire::Index.new(alias_name)
@@ -36,5 +37,87 @@ module Searchkick
       true
     end
 
+    private
+
+    def searchkick_index_options
+      options = @searchkick_options
+
+      settings = {
+        analysis: {
+          analyzer: {
+            searchkick_keyword: {
+              type: "custom",
+              tokenizer: "keyword",
+              filter: ["lowercase", "snowball"]
+            },
+            default_index: {
+              type: "custom",
+              tokenizer: "standard",
+              # synonym should come last, after stemming and shingle
+              # shingle must come before snowball
+              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_index_shingle"]
+            },
+            searchkick_search: {
+              type: "custom",
+              tokenizer: "standard",
+              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball", "searchkick_search_shingle"]
+            },
+            searchkick_search2: {
+              type: "custom",
+              tokenizer: "standard",
+              filter: ["standard", "lowercase", "asciifolding", "stop", "snowball"]
+            }
+          },
+          filter: {
+            searchkick_index_shingle: {
+              type: "shingle",
+              token_separator: ""
+            },
+            # lucky find http://web.archiveorange.com/archive/v/AAfXfQ17f57FcRINsof7
+            searchkick_search_shingle: {
+              type: "shingle",
+              token_separator: "",
+              output_unigrams: false,
+              output_unigrams_if_no_shingles: true
+            }
+          }
+        }
+      }.merge(options[:settings] || {})
+      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]}" }
+        }
+        settings[:analysis][:analyzer][:default_index][:filter] << "searchkick_synonym"
+        settings[:analysis][:analyzer][:searchkick_search][:filter].insert(-2, "searchkick_synonym")
+        settings[:analysis][:analyzer][:searchkick_search][:filter] << "searchkick_synonym"
+        settings[:analysis][:analyzer][:searchkick_search2][:filter] << "searchkick_synonym"
+      end
+
+      mapping = {}
+      if options[:conversions]
+        mapping[:conversions] = {
+          type: "nested",
+          properties: {
+            query: {type: "string", analyzer: "searchkick_keyword"},
+            count: {type: "integer"}
+          }
+        }
+      end
+
+      mappings = {
+        document_type.to_sym => {
+          properties: mapping
+        }
+      }
+
+      {
+        settings: settings,
+        mappings: mappings
+      }
+    end
+
   end
 end

data/lib/searchkick/search.rb

@@ -1,137 +1,147 @@
 module Searchkick
-  # can't check mapping for conversions since the new index may not be built
   module Search
-    def index_types
-      Hash[ (((Product.index.mapping || {})["product"] || {})["properties"] || {}).map{|k, v| [k, v["type"]] } ].reject{|k, v| k == "conversions" || k[0] == "_" }
-    end
 
     def search(term, options = {})
+      term = term.to_s
       fields = options[:fields] || ["_all"]
       operator = options[:partial] ? "or" : "and"
-      tire.search do
-        query do
-          boolean do
-            must 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: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search"
-                end
-                query do
-                  match fields, term, use_dis_max: false, fuzziness: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search2"
+      load = options[:load].nil? ? true : options[:load]
+      load = (options[:include] || true) if load
+
+      collection =
+        tire.search load: load, page: options[:page], per_page: options[:per_page] 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: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search"
+                    end
+                    query do
+                      match fields, term, use_dis_max: false, fuzziness: 0.7, max_expansions: 1, prefix_length: 1, operator: operator, analyzer: "searchkick_search2"
+                    end
+                  end
                 end
               end
-            end
-            if options[:conversions]
-              should do
-                nested path: "conversions", score_mode: "total" do
-                  query do
-                    custom_score script: "log(doc['count'].value)" do
-                      match "query", term
+              # can't check mapping for conversions since the new index may not be built
+              if options[:conversions]
+                should do
+                  nested path: "conversions", score_mode: "total" do
+                    query do
+                      custom_score script: "log(doc['count'].value)" do
+                        match "query", term
+                      end
                     end
                   end
                 end
               end
             end
           end
-        end
-        size options[:limit] || 100000 # return all - like sql query
-        from options[:offset] if options[:offset]
-        explain options[:explain] if options[:explain]
+          size options[:limit] || 100000 # return all - like sql query
+          from options[:offset] if options[:offset]
+          explain options[:explain] if options[:explain]
 
-        # order
-        if options[:order]
-          sort do
-            options[:order].each do |k, v|
-              by k, v
+          # order
+          if options[:order]
+            sort do
+              options[:order].each do |k, v|
+                by k, v
+              end
             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
+          # 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}
+                  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
-                          raise "Unknown where operator"
+                          filters << {not: {term: {field => op_value}}}
                         end
-                      filters << {range: {field => range_query}}
+                      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
                     end
+                  else
+                    filters << {term: {field => value}}
                   end
-                else
-                  filters << {term: {field => value}}
                 end
               end
+              filters
             end
-            filters
-          end
-
-        where_filters.call(options[:where]).each do |f|
-          type, value = f.first
-          filter type, value
-        end
 
-        # facets
-        if options[:facets]
-          facets = options[:facets] || {}
-          if facets.is_a?(Array) # convert to more advanced syntax
-            facets = Hash[ facets.map{|f| [f, {}] } ]
+          where_filters.call(options[:where]).each do |f|
+            type, value = f.first
+            filter type, value
           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
+          # facets
+          if options[:facets]
+            facets = options[:facets] || {}
+            if facets.is_a?(Array) # convert to more advanced syntax
+              facets = Hash[ facets.map{|f| [f, {}] } ]
+            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
         end
 
+      collection.each_with_hit do |model, hit|
+        model._score = hit["_score"].to_f / collection.max_score
       end
+      collection
     end
+
   end
 end

data/lib/searchkick/tasks.rb

@@ -4,6 +4,6 @@ namespace :searchkick do
   desc "re-index elasticsearch"
   task :reindex => :environment do
     klass = ENV["CLASS"].constantize
-    klass.tire.reindex
+    klass.reindex
   end
 end

data/lib/searchkick/version.rb

@@ -1,3 +1,3 @@
 module Searchkick
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/test/searchkick_test.rb

@@ -1,6 +1,8 @@
 require "test_helper"
 
 class Product < ActiveRecord::Base
+  has_many :searches
+
   searchkick \
     synonyms: [
       ["clorox", "bleach"],
@@ -15,24 +17,22 @@ class Product < ActiveRecord::Base
     },
     conversions: true
 
-  # searchkick do
-  #   string :name
-  #   boolean :visible
-  #   integer :orders_count
-  # end
+  def _source
+    as_json.merge conversions: searches.group("query").count
+  end
 end
 
-p Product.index_types
+class Search < ActiveRecord::Base
+  belongs_to :product
+end
+
+Product.reindex
 
 class TestSearchkick < Minitest::Unit::TestCase
 
   def setup
-    Product.index.delete
-    Product.create_elasticsearch_index
-  end
-
-  def test_reindex
-    assert Product.reindex
+    Search.delete_all
+    Product.destroy_all
   end
 
   # exact
@@ -106,16 +106,16 @@ class TestSearchkick < Minitest::Unit::TestCase
   # conversions
 
   def test_conversions
-    store [
-      {name: "Tomato Sauce", conversions: [{query: "tomato sauce", count: 5}, {query: "tomato", count: 200}]},
+    store_conversions [
+      {name: "Tomato Sauce", conversions: [{query: "tomato sauce", count: 5}, {query: "tomato", count: 20}]},
       {name: "Tomato Paste", conversions: []},
-      {name: "Tomatoes", conversions: [{query: "tomato", count: 100}, {query: "tomato sauce", count: 2}]}
+      {name: "Tomatoes", conversions: [{query: "tomato", count: 10}, {query: "tomato sauce", count: 2}]}
     ]
     assert_search "tomato", ["Tomato Sauce", "Tomatoes", "Tomato Paste"]
   end
 
   def test_conversions_stemmed
-    store [
+    store_conversions [
       {name: "Tomato A", conversions: [{query: "tomato", count: 2}, {query: "tomatos", count: 2}, {query: "Tomatoes", count: 2}]},
       {name: "Tomato B", conversions: [{query: "tomato", count: 4}]}
     ]
@@ -178,27 +178,17 @@ class TestSearchkick < Minitest::Unit::TestCase
 
   def test_boost
     store [
-      {name: "Organic Tomato A", _boost: 10},
-      {name: "Tomato B"}
+      {name: "Organic Tomato A"},
+      {name: "Tomato B", orders_count: 10}
     ]
-    assert_search "tomato", ["Organic Tomato A", "Tomato B"]
+    assert_search "tomato", ["Tomato B", "Organic Tomato A"], boost: "orders_count"
   end
 
   def test_boost_zero
     store [
-      {name: "Zero Boost", _boost: 0}
+      {name: "Zero Boost", orders_count: 0}
     ]
-    assert_search "zero", ["Zero Boost"]
-  end
-
-  # default to 1
-  def test_boost_null
-    store [
-      {name: "Zero Boost A", _boost: 1.1},
-      {name: "Zero Boost B"},
-      {name: "Zero Boost C", _boost: 0.9},
-    ]
-    assert_search "zero", ["Zero Boost A", "Zero Boost B", "Zero Boost C"]
+    assert_search "zero", ["Zero Boost"], boost: "orders_count"
   end
 
   # search method
@@ -216,10 +206,10 @@ class TestSearchkick < Minitest::Unit::TestCase
   def test_where
     now = Time.now
     store [
-      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, _boost: 4},
-      {name: "Product B", store_id: 2, in_stock: true, backordered: false, created_at: now - 1, _boost: 3},
-      {name: "Product C", store_id: 3, in_stock: false, backordered: true, created_at: now - 2, _boost: 2},
-      {name: "Product D", store_id: 4, in_stock: false, backordered: false, created_at: now - 3, _boost: 1},
+      {name: "Product A", store_id: 1, in_stock: true, backordered: true, created_at: now, orders_count: 4},
+      {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},
     ]
     assert_search "product", ["Product A", "Product B"], where: {in_stock: true}
     # date
@@ -267,7 +257,7 @@ class TestSearchkick < Minitest::Unit::TestCase
 
   def store(documents)
     documents.each do |document|
-      Product.index.store ({_type: "product"}).merge(document)
+      Product.create!(document)
     end
     Product.index.refresh
   end
@@ -276,6 +266,20 @@ class TestSearchkick < Minitest::Unit::TestCase
     store names.map{|name| {name: name} }
   end
 
+  def store_conversions(documents)
+    documents.each do |document|
+      conversions = document.delete(:conversions)
+      product = Product.create!(document)
+      conversions.each do |c|
+        c[:count].times do
+          product.searches.create!(query: c[:query])
+        end
+      end
+    end
+    Product.reindex
+    Product.index.refresh
+  end
+
   def assert_search(term, expected, options = {})
     assert_equal expected, Product.search(term, options.merge(fields: [:name], conversions: true)).map(&:name)
   end

data/test/test_helper.rb

@@ -19,8 +19,17 @@ ActiveRecord::Migration.create_table :products, :force => true do |t|
   t.integer :store_id
   t.boolean :in_stock
   t.boolean :backordered
+  t.integer :orders_count
+  t.string :color
   t.timestamps
 end
 
+ActiveRecord::Migration.create_table :searches, :force => true do |t|
+  t.string :query
+  t.timestamp :searched_at
+  t.timestamp :converted_at
+  t.references :product
+end
+
 File.delete("elasticsearch.log") if File.exists?("elasticsearch.log")
 Tire.configure { logger "elasticsearch.log", :level => "debug" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: searchkick
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: tire