searchkick 1.3.4 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e771f2aea318aada5efd68350c101abca94a77a8
-  data.tar.gz: 4c3d8566133e79b6456609a9d50faf84be229454
+  metadata.gz: e69261f029a233983def6aaec3cd101621807fe8
+  data.tar.gz: 93d6d5e53193af4ae04537c012845d336a9b7197
 SHA512:
-  metadata.gz: 67375bbcd44840170e0fc29eeb84308f4e6814b24c30e8c8e6d0ed177df04dc038f7d0f4084d9cba19a2f5116249bb8313a37b01707e4163a83aeccc89a812c1
-  data.tar.gz: e31a38b61ed0ddf786f7aaf8be45eb39a938122305a9886d60fc33eaac335b267c468e1fb01511bf5863ca390bea86b216e822461422656e956c423948a3361c
+  metadata.gz: 2a2f79b352af2ae191c719480e648e07fc8083e3d6c836632e5f1f5245786386bad8e0397d15f3c13771a7197e92052a9c2ba269de23f3f5858fb528642eff26
+  data.tar.gz: 57972ac3b439dcbf77bef6d9f121383f93822ae3e3c0b6bbf64baedbe0f46a2dd1dd8c9ded33a0384bb80abb5922a33bd216cdeea9271c25f7dc754fd0f7c5a4

data/.travis.yml

@@ -24,7 +24,7 @@ gemfile:
   - test/gemfiles/mongoid4.gemfile
   - test/gemfiles/mongoid5.gemfile
 env:
-  - ELASTICSEARCH_VERSION=2.3.0
+  - ELASTICSEARCH_VERSION=2.4.0
 matrix:
   include:
     - gemfile: Gemfile
@@ -34,11 +34,11 @@ matrix:
     - gemfile: Gemfile
       env: ELASTICSEARCH_VERSION=2.0.0
     - gemfile: Gemfile
-      env: ELASTICSEARCH_VERSION=5.0.0-alpha2
+      env: ELASTICSEARCH_VERSION=5.0.0-beta1
     # - gemfile: test/gemfiles/nobrainer.gemfile
     #   env: NOBRAINER=true
   allow_failures:
     - gemfile: Gemfile
-      env: ELASTICSEARCH_VERSION=5.0.0-alpha2
+      env: ELASTICSEARCH_VERSION=5.0.0-beta1
     # - gemfile: test/gemfiles/nobrainer.gemfile
     #   env: NOBRAINER=true

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 1.3.5
+
+- Added support for Elasticsearch 5.0 beta
+- Added `request_params` option
+- Added `filterable` option
+
 ## 1.3.4
 
 - Added `resume` option to reindex

data/Gemfile

@@ -6,3 +6,4 @@ gemspec
 gem "sqlite3"
 gem "activerecord", "~> 5.0.0"
 gem "gemoji-parser"
+gem "typhoeus"

data/README.md

@@ -116,6 +116,12 @@ Limit / offset
 limit: 20, offset: 40
 ```
 
+Select
+
+```ruby
+select_v2: ["name"]
+```
+
 ### Results
 
 Searches return a `Searchkick::Results` object. This responds like an array to most methods.
@@ -127,6 +133,12 @@ results.any?
 results.each { |result| ... }
 ```
 
+By default, ids are fetched from Elasticsearch and records are fetched from your database. To fetch everything from Elasticsearch, use:
+
+```ruby
+Product.search("apples", load: false)
+```
+
 Get total results
 
 ```ruby
@@ -476,7 +488,7 @@ Next, add conversions to the index.
 
 ```ruby
 class Product < ActiveRecord::Base
-  has_many :searches, class_name: "Searchjoy::Search"
+  has_many :searches, class_name: "Searchjoy::Search", as: :convertable
 
   searchkick conversions: ["conversions"] # name of field
 
@@ -593,7 +605,7 @@ products.suggestions # ["peanut butter"]
 
 ### Aggregations
 
-[Aggregations](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-facets.html) provide aggregated search data.
+[Aggregations](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-aggregations.html) provide aggregated search data.
 
 ![Aggregations](https://raw.githubusercontent.com/ankane/searchkick/gh-pages/facets.png)
 
@@ -1121,7 +1133,7 @@ products =
   end
 ```
 
-### Multi Search
+## Multi Search
 
 To batch search requests for performance, use:
 
@@ -1135,7 +1147,7 @@ Then use `fresh_products` and `frozen_products` as typical results.
 
 **Note:** Errors are not raised as with single requests. Use the `error` method on each query to check for errors. Also, if you use the `below` option for misspellings, misspellings will be disabled.
 
-### Multiple Indices
+## Multiple Indices
 
 Search across multiple indices with:
 
@@ -1149,6 +1161,14 @@ Boost specific indices with:
 indices_boost: {Category => 2, Product => 1}
 ```
 
+## Nested Data
+
+To query nested data, use dot notation.
+
+```ruby
+User.search "*", where: {"address.zip_code" => 12345}
+```
+
 ## Reference
 
 Reindex one record
@@ -1267,13 +1287,7 @@ Searchkick.search_method_name = :lookup
 Eager load associations
 
 ```ruby
-Product.search "milk", include: [:brand, :stores]
-```
-
-Do not load models
-
-```ruby
-Product.search "milk", load: false
+Product.search "milk", includes: [:brand, :stores]
 ```
 
 Turn off special characters
@@ -1314,6 +1328,12 @@ products = Product.search("carrots", execute: false)
 products.each { ... } # search not executed until here
 ```
 
+Add [request parameters](https://www.elastic.co/guide/en/elasticsearch/reference/current/search-uri-request.html), like `search_type` and `query_cache`
+
+```ruby
+Product.search("carrots", request_params: {search_type: "dfs_query_then_fetch"})
+```
+
 Make fields unsearchable but include in the source
 
 ```ruby

data/lib/searchkick.rb

@@ -2,6 +2,7 @@ require "active_model"
 require "elasticsearch"
 require "hashie"
 require "searchkick/version"
+require "searchkick/index_options"
 require "searchkick/index"
 require "searchkick/results"
 require "searchkick/query"
@@ -11,14 +12,6 @@ require "searchkick/tasks"
 require "searchkick/middleware"
 require "searchkick/logging" if defined?(ActiveSupport::Notifications)
 
-# background jobs
-begin
-  require "active_job"
-rescue LoadError
-  # do nothing
-end
-require "searchkick/reindex_v2_job" if defined?(ActiveJob)
-
 module Searchkick
   class Error < StandardError; end
   class MissingIndexError < Error; end
@@ -37,13 +30,16 @@ module Searchkick
   self.models = []
 
   def self.client
-    @client ||=
+    @client ||= begin
+      require "typhoeus/adapters/faraday" if defined?(Typhoeus)
+
       Elasticsearch::Client.new(
         url: ENV["ELASTICSEARCH_URL"],
-        transport_options: {request: {timeout: timeout}}
+        transport_options: {request: {timeout: timeout}, headers: {content_type: "application/json"}}
       ) do |f|
         f.use Searchkick::Middleware
       end
+    end
   end
 
   def self.env
@@ -156,6 +152,13 @@ module Searchkick
   end
 end
 
+ActiveSupport.on_load(:active_job) do
+  require "searchkick/reindex_v2_job"
+end
+
 # TODO find better ActiveModel hook
 ActiveModel::Callbacks.send(:include, Searchkick::Model)
-ActiveRecord::Base.send(:extend, Searchkick::Model) if defined?(ActiveRecord)
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.send(:extend, Searchkick::Model)
+end

data/lib/searchkick/index.rb

@@ -1,5 +1,7 @@
 module Searchkick
   class Index
+    include IndexOptions
+
     attr_reader :name, :options
 
     def initialize(name, options = {})
@@ -95,8 +97,10 @@ module Searchkick
       if Searchkick.callbacks_value.nil?
         if defined?(Searchkick::ReindexV2Job)
           Searchkick::ReindexV2Job.perform_later(record.class.name, record.id.to_s)
-        else
+        elsif defined?(Delayed::Job)
           Delayed::Job.enqueue Searchkick::ReindexJob.new(record.class.name, record.id.to_s)
+        else
+          raise Searchkick::Error, "Job adapter not found"
         end
       else
         reindex_record(record)
@@ -123,7 +127,7 @@ module Searchkick
 
     def search_model(searchkick_klass, term = nil, options = {}, &block)
       query = Searchkick::Query.new(searchkick_klass, term, options)
-      block.call(query.body) if block
+      yield(query.body) if block
       if options[:execute] == false
         query
       else
@@ -147,8 +151,8 @@ module Searchkick
         rescue Elasticsearch::Transport::Transport::Errors::NotFound
           {}
         end
-      indices = indices.select { |k, v| v.empty? || v["aliases"].empty? } if options[:unaliased]
-      indices.select { |k, v| k =~ /\A#{Regexp.escape(name)}_\d{14,17}\z/ }.keys
+      indices = indices.select { |_k, v| v.empty? || v["aliases"].empty? } if options[:unaliased]
+      indices.select { |k, _v| k =~ /\A#{Regexp.escape(name)}_\d{14,17}\z/ }.keys
     end
 
     # remove old indices that start w/ index_name
@@ -244,357 +248,6 @@ module Searchkick
       end
     end
 
-    def index_options
-      options = @options
-      language = options[:language]
-      language = language.call if language.respond_to?(:call)
-
-      if options[:mappings] && !options[:merge_mappings]
-        settings = options[:settings] || {}
-        mappings = options[:mappings]
-      else
-        below22 = Searchkick.server_below?("2.2.0")
-        below50 = Searchkick.server_below?("5.0.0-alpha1")
-        default_type = below50 ? "string" : "text"
-        default_analyzer = below50 ? :default_index : :default
-        keyword_mapping =
-          if below50
-            {
-              type: default_type,
-              index: "not_analyzed"
-            }
-          else
-            {
-              type: "keyword"
-            }
-          end
-
-        keyword_mapping[:ignore_above] = 256 unless below22
-
-        settings = {
-          analysis: {
-            analyzer: {
-              searchkick_keyword: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase"] + (options[:stem_conversions] == false ? [] : ["searchkick_stemmer"])
-              },
-              default_analyzer => {
-                type: "custom",
-                # character filters -> tokenizer -> token filters
-                # https://www.elastic.co/guide/en/elasticsearch/guide/current/analysis-intro.html
-                char_filter: ["ampersand"],
-                tokenizer: "standard",
-                # synonym should come last, after stemming and shingle
-                # shingle must come before searchkick_stemmer
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_index_shingle", "searchkick_stemmer"]
-              },
-              searchkick_search: {
-                type: "custom",
-                char_filter: ["ampersand"],
-                tokenizer: "standard",
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_search_shingle", "searchkick_stemmer"]
-              },
-              searchkick_search2: {
-                type: "custom",
-                char_filter: ["ampersand"],
-                tokenizer: "standard",
-                filter: ["standard", "lowercase", "asciifolding", "searchkick_stemmer"]
-              },
-              # https://github.com/leschenko/elasticsearch_autocomplete/blob/master/lib/elasticsearch_autocomplete/analyzers.rb
-              searchkick_autocomplete_index: {
-                type: "custom",
-                tokenizer: "searchkick_autocomplete_ngram",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_autocomplete_search: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_word_search: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding"]
-              },
-              searchkick_suggest_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_suggest_shingle"]
-              },
-              searchkick_text_start_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "searchkick_edge_ngram"]
-              },
-              searchkick_text_middle_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "searchkick_ngram"]
-              },
-              searchkick_text_end_index: {
-                type: "custom",
-                tokenizer: "keyword",
-                filter: ["lowercase", "asciifolding", "reverse", "searchkick_edge_ngram", "reverse"]
-              },
-              searchkick_word_start_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_edge_ngram"]
-              },
-              searchkick_word_middle_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "searchkick_ngram"]
-              },
-              searchkick_word_end_index: {
-                type: "custom",
-                tokenizer: "standard",
-                filter: ["lowercase", "asciifolding", "reverse", "searchkick_edge_ngram", "reverse"]
-              }
-            },
-            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
-              },
-              searchkick_suggest_shingle: {
-                type: "shingle",
-                max_shingle_size: 5
-              },
-              searchkick_edge_ngram: {
-                type: "edgeNGram",
-                min_gram: 1,
-                max_gram: 50
-              },
-              searchkick_ngram: {
-                type: "nGram",
-                min_gram: 1,
-                max_gram: 50
-              },
-              searchkick_stemmer: {
-                # use stemmer if language is lowercase, snowball otherwise
-                # TODO deprecate language option in favor of stemmer
-                type: language == language.to_s.downcase ? "stemmer" : "snowball",
-                language: language || "English"
-              }
-            },
-            char_filter: {
-              # https://www.elastic.co/guide/en/elasticsearch/guide/current/custom-analyzers.html
-              # &_to_and
-              ampersand: {
-                type: "mapping",
-                mappings: ["&=> and "]
-              }
-            },
-            tokenizer: {
-              searchkick_autocomplete_ngram: {
-                type: "edgeNGram",
-                min_gram: 1,
-                max_gram: 50
-              }
-            }
-          }
-        }
-
-        if Searchkick.env == "test"
-          settings.merge!(number_of_shards: 1, number_of_replicas: 0)
-        end
-
-        if options[:similarity]
-          settings[:similarity] = {default: {type: options[:similarity]}}
-        end
-
-        settings.deep_merge!(options[:settings] || {})
-
-        # synonyms
-        synonyms = options[:synonyms] || []
-
-        synonyms = synonyms.call if synonyms.respond_to?(:call)
-
-        if synonyms.any?
-          settings[:analysis][:filter][:searchkick_synonym] = {
-            type: "synonym",
-            synonyms: synonyms.select { |s| s.size > 1 }.map { |s| s.join(",") }
-          }
-          # choosing a place for the synonym filter when stemming is not easy
-          # https://groups.google.com/forum/#!topic/elasticsearch/p7qcQlgHdB8
-          # TODO use a snowball stemmer on synonyms when creating the token filter
-
-          # http://elasticsearch-users.115913.n3.nabble.com/synonym-multi-words-search-td4030811.html
-          # I find the following approach effective if you are doing multi-word synonyms (synonym phrases):
-          # - Only apply the synonym expansion at index time
-          # - Don't have the synonym filter applied search
-          # - Use directional synonyms where appropriate. You want to make sure that you're not injecting terms that are too general.
-          settings[:analysis][:analyzer][default_analyzer][:filter].insert(4, "searchkick_synonym")
-          settings[:analysis][:analyzer][default_analyzer][:filter] << "searchkick_synonym"
-
-          %w(word_start word_middle word_end).each do |type|
-            settings[:analysis][:analyzer]["searchkick_#{type}_index".to_sym][:filter].insert(2, "searchkick_synonym")
-          end
-        end
-
-        if options[:wordnet]
-          settings[:analysis][:filter][:searchkick_wordnet] = {
-            type: "synonym",
-            format: "wordnet",
-            synonyms_path: Searchkick.wordnet_path
-          }
-
-          settings[:analysis][:analyzer][default_analyzer][:filter].insert(4, "searchkick_wordnet")
-          settings[:analysis][:analyzer][default_analyzer][:filter] << "searchkick_wordnet"
-
-          %w(word_start word_middle word_end).each do |type|
-            settings[:analysis][:analyzer]["searchkick_#{type}_index".to_sym][:filter].insert(2, "searchkick_wordnet")
-          end
-        end
-
-        if options[:special_characters] == false
-          settings[:analysis][:analyzer].each do |_, analyzer_settings|
-            analyzer_settings[:filter].reject! { |f| f == "asciifolding" }
-          end
-        end
-
-        mapping = {}
-
-        # conversions
-        Array(options[:conversions]).each do |conversions_field|
-          mapping[conversions_field] = {
-            type: "nested",
-            properties: {
-              query: {type: default_type, analyzer: "searchkick_keyword"},
-              count: {type: "integer"}
-            }
-          }
-        end
-
-        mapping_options = Hash[
-          [:autocomplete, :suggest, :word, :text_start, :text_middle, :text_end, :word_start, :word_middle, :word_end, :highlight, :searchable, :only_analyzed]
-            .map { |type| [type, (options[type] || []).map(&:to_s)] }
-        ]
-
-        word = options[:word] != false && (!options[:match] || options[:match] == :word)
-
-        mapping_options.values.flatten.uniq.each do |field|
-          fields = {}
-
-          if mapping_options[:only_analyzed].include?(field)
-            fields[field] = {type: default_type, index: "no"}
-          else
-            fields[field] = keyword_mapping
-          end
-
-          if !options[:searchable] || mapping_options[:searchable].include?(field)
-            if word
-              fields["analyzed"] = {type: default_type, index: "analyzed", analyzer: default_analyzer}
-
-              if mapping_options[:highlight].include?(field)
-                fields["analyzed"][:term_vector] = "with_positions_offsets"
-              end
-            end
-
-            mapping_options.except(:highlight, :searchable, :only_analyzed).each do |type, f|
-              if options[:match] == type || f.include?(field)
-                fields[type] = {type: default_type, index: "analyzed", analyzer: "searchkick_#{type}_index"}
-              end
-            end
-          end
-
-          mapping[field] =
-            if below50
-              {
-                type: "multi_field",
-                fields: fields
-              }
-            elsif fields[field]
-              fields[field].merge(fields: fields.except(field))
-           end
-        end
-
-        (options[:locations] || []).map(&:to_s).each do |field|
-          mapping[field] = {
-            type: "geo_point"
-          }
-        end
-
-        (options[:unsearchable] || []).map(&:to_s).each do |field|
-          mapping[field] = {
-            type: default_type,
-            index: "no"
-          }
-        end
-
-        routing = {}
-        if options[:routing]
-          routing = {required: true}
-          unless options[:routing] == true
-            routing[:path] = options[:routing].to_s
-          end
-        end
-
-        dynamic_fields = {
-          # analyzed field must be the default field for include_in_all
-          # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
-          # however, we can include the not_analyzed field in _all
-          # and the _all index analyzer will take care of it
-          "{name}" => keyword_mapping.merge(include_in_all: !options[:searchable])
-        }
-
-        dynamic_fields["{name}"][:ignore_above] = 256 unless below22
-
-        unless options[:searchable]
-          if options[:match] && options[:match] != :word
-            dynamic_fields[options[:match]] = {type: default_type, index: "analyzed", analyzer: "searchkick_#{options[:match]}_index"}
-          end
-
-          if word
-            dynamic_fields["analyzed"] = {type: default_type, index: "analyzed"}
-          end
-        end
-
-        # http://www.elasticsearch.org/guide/reference/mapping/multi-field-type/
-        multi_field =
-          if below50
-            {
-              type: "multi_field",
-              fields: dynamic_fields
-            }
-          else
-            dynamic_fields["{name}"].merge(fields: dynamic_fields.except("{name}"))
-          end
-
-        mappings = {
-          _default_: {
-            _all: {type: default_type, index: "analyzed", analyzer: default_analyzer},
-            properties: mapping,
-            _routing: routing,
-            # https://gist.github.com/kimchy/2898285
-            dynamic_templates: [
-              {
-                string_template: {
-                  match: "*",
-                  match_mapping_type: "string",
-                  mapping: multi_field
-                }
-              }
-            ]
-          }
-        }.deep_merge(options[:mappings] || {})
-      end
-
-      {
-        settings: settings,
-        mappings: mappings
-      }
-    end
-
     # other
 
     def tokens(text, options = {})
@@ -634,10 +287,10 @@ module Searchkick
 
       # stringify fields
       # remove _id since search_id is used instead
-      source = source.inject({}) { |memo, (k, v)| memo[k.to_s] = v; memo }.except("_id")
+      source = source.each_with_object({}) { |(k, v), memo| memo[k.to_s] = v; memo }.except("_id")
 
       # conversions
-      Array(options[:conversions]).each do |conversions_field|
+      Array(options[:conversions]).map(&:to_s).each do |conversions_field|
         if source[conversions_field]
           source[conversions_field] = source[conversions_field].map { |k, v| {query: k, count: v} }
         end