searchkick-sinneduy 0.9.0

data/lib/searchkick/reindex_job.rb

@@ -0,0 +1,28 @@
+module Searchkick
+  class ReindexJob
+
+    def initialize(klass, id)
+      @klass = klass
+      @id = id
+    end
+
+    def perform
+      model = @klass.constantize
+      record = model.find(@id) rescue nil # TODO fix lazy coding
+      index = model.searchkick_index
+      if !record || !record.should_index?
+        # hacky
+        record ||= model.new
+        record.id = @id
+        begin
+          index.remove record
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          # do nothing
+        end
+      else
+        index.store record
+      end
+    end
+
+  end
+end

data/lib/searchkick/reindex_v2_job.rb

@@ -0,0 +1,24 @@
+module Searchkick
+  class ReindexV2Job < ActiveJob::Base
+    queue_as :searchkick
+
+    def perform(klass, id)
+      model = klass.constantize
+      record = model.find(id) rescue nil # TODO fix lazy coding
+      index = model.searchkick_index
+      if !record || !record.should_index?
+        # hacky
+        record ||= model.new
+        record.id = id
+        begin
+          index.remove record
+        rescue Elasticsearch::Transport::Transport::Errors::NotFound
+          # do nothing
+        end
+      else
+        index.store record
+      end
+    end
+
+  end
+end

data/lib/searchkick/results.rb

@@ -0,0 +1,158 @@
+require "forwardable"
+
+module Searchkick
+  class Results
+    include Enumerable
+    extend Forwardable
+
+    attr_reader :klass, :response, :options
+
+    def_delegators :results, :each, :any?, :empty?, :size, :length, :slice, :[], :to_ary
+
+    def initialize(klass, response, options = {})
+      @klass = klass
+      @response = response
+      @options = options
+    end
+
+    def results
+      @results ||= begin
+        if options[:load]
+          # results can have different types
+          results = {}
+
+          hits.group_by { |hit, i| hit["_type"] }.each do |type, grouped_hits|
+            records = type.camelize.constantize
+            if options[:includes]
+              if defined?(NoBrainer::Document) && records < NoBrainer::Document
+                records = records.preload(options[:includes])
+              else
+                records = records.includes(options[:includes])
+              end
+            end
+            results[type] = results_query(records, grouped_hits)
+          end
+
+          # sort
+          hits.map do |hit|
+            results[hit["_type"]].find { |r| r.id.to_s == hit["_id"].to_s }
+          end.compact
+        else
+          hits.map do |hit|
+            result =
+              if hit["_source"]
+                hit.except("_source").merge(hit["_source"])
+              else
+                hit.except("fields").merge(hit["fields"])
+              end
+            result["id"] ||= result["_id"] # needed for legacy reasons
+            Hashie::Mash.new(result)
+          end
+        end
+      end
+    end
+
+    def suggestions
+      if response["suggest"]
+        response["suggest"].values.flat_map { |v| v.first["options"] }.sort_by { |o| -o["score"] }.map { |o| o["text"] }.uniq
+      else
+        raise "Pass `suggest: true` to the search method for suggestions"
+      end
+    end
+
+    def each_with_hit(&block)
+      results.zip(hits).each(&block)
+    end
+
+    def with_details
+      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] }]
+        end
+        [model, details]
+      end
+    end
+
+    def facets
+      response["facets"]
+    end
+
+    def model_name
+      klass.model_name
+    end
+
+    def entry_name
+      model_name.human.downcase
+    end
+
+    def total_count
+      response["hits"]["total"]
+    end
+    alias_method :total_entries, :total_count
+
+    def current_page
+      options[:page]
+    end
+
+    def per_page
+      options[:per_page]
+    end
+    alias_method :limit_value, :per_page
+
+    def padding
+      options[:padding]
+    end
+
+    def total_pages
+      (total_count / per_page.to_f).ceil
+    end
+    alias_method :num_pages, :total_pages
+
+    def offset_value
+      (current_page - 1) * per_page + padding
+    end
+    alias_method :offset, :offset_value
+
+    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
+    end
+
+    def first_page?
+      previous_page.nil?
+    end
+
+    def last_page?
+      next_page.nil?
+    end
+
+    def hits
+      @response["hits"]["hits"]
+    end
+
+    private
+
+    def results_query(records, grouped_hits)
+      if records.respond_to?(:primary_key) && records.primary_key
+        # ActiveRecord
+        records.where(records.primary_key => grouped_hits.map { |hit| hit["_id"] }).to_a
+      elsif records.respond_to?(:all) && records.all.respond_to?(:for_ids)
+        # Mongoid 2
+        records.all.for_ids(grouped_hits.map { |hit| hit["_id"] }).to_a
+      elsif records.respond_to?(:queryable)
+        # Mongoid 3+
+        records.queryable.for_ids(grouped_hits.map { |hit| hit["_id"] }).to_a
+      elsif records.respond_to?(:unscoped) && records.all.respond_to?(:preload)
+        # Nobrainer
+        records.unscoped.where(:id.in => grouped_hits.map { |hit| hit["_id"] }).to_a
+      else
+        raise "Not sure how to load records"
+      end
+    end
+  end
+end

data/lib/searchkick/tasks.rb

@@ -0,0 +1,35 @@
+require "rake"
+
+namespace :searchkick do
+
+  desc "reindex model"
+  task reindex: :environment do
+    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.models.each do |model|
+          puts "Reindexing #{model.name}..."
+          model.reindex
+        end
+        puts "Reindex complete"
+      end
+    end
+
+  end
+
+end

data/lib/searchkick/version.rb

@@ -0,0 +1,3 @@
+module Searchkick
+  VERSION = "0.9.0"
+end

data/searchkick.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "searchkick/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "searchkick-sinneduy"
+  spec.version       = Searchkick::VERSION
+  spec.authors       = ["Andrew Kane"]
+  spec.email         = ["andrew@chartkick.com"]
+  spec.description   = "Intelligent search made easy"
+  spec.summary       = "Searchkick learns what your users are looking for. As more people search, it gets smarter and the results get better. It’s friendly for developers - and magical for your users."
+  spec.homepage      = "https://github.com/ankane/searchkick"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activemodel"
+  spec.add_dependency "elasticsearch-sinneduy", ">= 1.0.13"
+  spec.add_dependency "hashie"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/test/autocomplete_test.rb

@@ -0,0 +1,67 @@
+require_relative "test_helper"
+
+class TestAutocomplete < Minitest::Test
+
+  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
+
+  def test_text_start
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_start}]
+    assert_search "in the world", [], fields: [{name: :text_start}]
+  end
+
+  def test_text_middle
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "where in the world is", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "n the wor", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_middle}]
+    assert_search "world carmen", [], fields: [{name: :text_middle}]
+  end
+
+  def test_text_end
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "men san diego", ["Where in the World is Carmen San Diego"], fields: [{name: :text_end}]
+    assert_search "carmen san", [], fields: [{name: :text_end}]
+  end
+
+  def test_word_start
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "car san wor", ["Where in the World is Carmen San Diego"], fields: [{name: :word_start}]
+  end
+
+  def test_word_middle
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "orl", ["Where in the World is Carmen San Diego"], fields: [{name: :word_middle}]
+  end
+
+  def test_word_end
+    store_names ["Where in the World is Carmen San Diego"]
+    assert_search "rld men ego", ["Where in the World is Carmen San Diego"], fields: [{name: :word_end}]
+  end
+
+  def test_word_start_multiple_words
+    store_names ["Dark Grey", "Dark Blue"]
+    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/boost_test.rb

@@ -0,0 +1,126 @@
+require_relative "test_helper"
+
+class TestBoost < Minitest::Test
+
+  # conversions
+
+  def test_conversions
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}},
+      {name: "Tomato C", conversions: {"tomato" => 3}}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"]
+  end
+
+  def test_conversions_stemmed
+    store [
+      {name: "Tomato A", conversions: {"tomato" => 1, "tomatos" => 1, "Tomatoes" => 1}},
+      {name: "Tomato B", conversions: {"tomato" => 2}}
+    ]
+    assert_order "tomato", ["Tomato A", "Tomato B"]
+  end
+
+  # global boost
+
+  def test_boost
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost: "orders_count"
+  end
+
+  def test_boost_zero
+    store [
+      {name: "Zero Boost", orders_count: 0}
+    ]
+    assert_order "zero", ["Zero Boost"], boost: "orders_count"
+  end
+
+  def test_conversions_weight
+    store [
+      {name: "Product Boost", orders_count: 20},
+      {name: "Product Conversions", conversions: {"product" => 10}}
+    ]
+    assert_order "product", ["Product Conversions", "Product Boost"], boost: "orders_count"
+  end
+
+  def test_user_id
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2, 3]},
+      {name: "Tomato C"},
+      {name: "Tomato D"}
+    ]
+    assert_first "tomato", "Tomato B", user_id: 2
+  end
+
+  def test_personalize
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2, 3]},
+      {name: "Tomato C"},
+      {name: "Tomato D"}
+    ]
+    assert_first "tomato", "Tomato B", personalize: {user_ids: 2}
+  end
+
+  def test_boost_fields
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10", "color"]
+  end
+
+  def test_boost_fields_decimal
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: ["name^10.5", "color"]
+  end
+
+  def test_boost_fields_word_start
+    store [
+      {name: "Red", color: "White"},
+      {name: "White", color: "Red Red Red"}
+    ]
+    assert_order "red", ["Red", "White"], fields: [{"name^10" => :word_start}, "color"]
+  end
+
+  def test_boost_by
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", orders_count: 10},
+      {name: "Tomato C", orders_count: 100}
+    ]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: [:orders_count]
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_by: {orders_count: {factor: 10}}
+  end
+
+  def test_boost_where
+    store [
+      {name: "Tomato A"},
+      {name: "Tomato B", user_ids: [1, 2]},
+      {name: "Tomato C", user_ids: [3]}
+    ]
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: 2}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: [1, 4]}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: 2, factor: 10}}
+    assert_first "tomato", "Tomato B", boost_where: {user_ids: {value: [1, 4], factor: 10}}
+    assert_order "tomato", ["Tomato C", "Tomato B", "Tomato A"], boost_where: {user_ids: [{value: 1, factor: 10}, {value: 3, factor: 20}]}
+  end
+
+  def test_boost_by_distance
+    store [
+      {name: "San Francisco", latitude: 37.7833, longitude: -122.4167},
+      {name: "San Antonio", latitude: 29.4167, longitude: -98.5000},
+      {name: "San Marino", latitude: 43.9333, longitude: 12.4667}
+    ]
+    assert_order "san", ["San Francisco", "San Antonio", "San Marino"], boost_by_distance: {field: :location, origin: [37, -122], scale: "1000mi"}
+  end
+
+end