chewy 0.4.1 → 0.5.0

data/lib/chewy/errors.rb

@@ -11,7 +11,7 @@ module Chewy
   class UnderivableType < Error
   end
 
-  class FailedImport < Error
+  class ImportFailed < Error
     def initialize type, errors
       output = "Import failed for `#{type}` with:\n"
       errors.each do |action, errors|

data/lib/chewy/fields/base.rb

@@ -4,23 +4,33 @@ module Chewy
       attr_reader :name, :options, :value
 
       def initialize(name, options = {})
-        @name, @options, @nested = name.to_sym, options, {}
+        @name, @options, @nested = name.to_sym, options.deep_symbolize_keys, {}
         @value = @options.delete(:value)
       end
 
       def multi_field?
-        @options[:type] == 'multi_field'
+        nested.any? && !object_field?
+      end
+
+      def object_field?
+        (nested.any? && options[:type].blank?) || options[:type].to_s == 'object'
+      end
+
+      def root_field?
+        false
       end
 
       def compose(object)
         result = if value && value.is_a?(Proc)
           value.arity == 0 ? object.instance_exec(&value) : value.call(object)
+        elsif object.is_a?(Hash)
+          object[name] || object[name.to_s]
         else
           object.send(name)
         end
 
-        result = if result.is_a?(Enumerable) && !result.is_a?(Hash)
-          result.map { |object| nested_compose(object) }
+        result = if result.respond_to?(:to_ary)
+          result.to_ary.map { |object| nested_compose(object) }
         else
           nested_compose(result)
         end if nested.any? && !multi_field?
@@ -37,16 +47,18 @@ module Chewy
       end
 
       def mappings_hash
-        subfields = nested.any? ? {
+        mapping = nested.any? ? {
           (multi_field? ? :fields : :properties) => nested.values.map(&:mappings_hash).inject(:merge)
         } : {}
-        {name => options.deep_symbolize_keys.merge(subfields)}
+        mapping.reverse_merge!(options)
+        mapping.reverse_merge!(type: (nested.any? ? 'object' : 'string')) unless root_field?
+        {name => mapping}
       end
 
     private
 
       def nested_compose(value)
-        nested.values.map { |field| field.compose(value) }.inject(:merge)
+        nested.values.map { |field| field.compose(value) if value }.compact.inject(:merge)
       end
     end
   end

data/lib/chewy/fields/root.rb

@@ -6,9 +6,22 @@ module Chewy
       def initialize(name, options = {})
         options.reverse_merge!(value: ->(_){_})
         super(name, options)
+        options.delete(:type)
         @dynamic_templates = []
       end
 
+      def multi_field?
+        false
+      end
+
+      def object_field?
+        true
+      end
+
+      def root_field?
+        true
+      end
+
       def mappings_hash
         mappings = super
         if dynamic_templates.any?

data/lib/chewy/index/actions.rb

@@ -56,10 +56,16 @@ module Chewy
           options = args.extract_options!.reverse_merge!(alias: true)
           name = build_index_name(suffix: args.first)
 
-          Chewy.wait_for_status
+          if Chewy::Runtime.version >= 1.1
+            body = index_params
+            body.merge!(aliases: {index_name => {}}) if options[:alias] && name != index_name
+            result = client.indices.create(index: name, body: body)
+          else
+            result = client.indices.create(index: name, body: index_params)
+            result &&= client.indices.put_alias(index: name, name: index_name) if options[:alias] && name != index_name
+          end
 
-          result = client.indices.create(index: name, body: index_params)
-          result &&= client.indices.put_alias(index: name, name: index_name) if options[:alias] && name != index_name
+          Chewy.wait_for_status if result
           result
         end
 
@@ -87,9 +93,9 @@ module Chewy
         #   UsersIndex.delete '01-2014' # deletes `users_01-2014` index
         #
         def delete! suffix = nil
-          Chewy.wait_for_status
-
-          client.indices.delete index: build_index_name(suffix: suffix)
+          result = client.indices.delete index: build_index_name(suffix: suffix)
+          Chewy.wait_for_status if result
+          result
         end
 
         # Deletes and recreates index. Supports suffixes.
@@ -128,6 +134,8 @@ module Chewy
         #   UsersIndex.import suffix: Time.now.to_i     # imports data to index with specified suffix if such is exists
         #   UsersIndex.import batch_size: 300           # import batch size
         #
+        # See [import.rb](lib/chewy/type/import.rb) for more details.
+        #
         [:import, :import!].each do |method|
           class_eval <<-METHOD, __FILE__, __LINE__ + 1
             def #{method} options = {}

data/lib/chewy/index/search.rb

@@ -4,8 +4,9 @@ module Chewy
       extend ActiveSupport::Concern
 
       included do
-        singleton_class.delegate :explain, :limit, :offset, :facets, :aggregations, :query,
-          :filter, :order, :reorder, :only, :types, :none, to: :all
+        singleton_class.delegate :explain, :limit, :offset, :highlight, :rescore,
+          :facets, :aggregations, :none, :strategy, :query, :filter, :post_filter,
+          :order, :reorder, :only, :types, :suggest, to: :all
       end
 
       module ClassMethods

data/lib/chewy/query.rb

@@ -1,8 +1,3 @@
-begin
-  require 'kaminari'
-rescue LoadError
-end
-
 require 'chewy/query/criteria'
 require 'chewy/query/filters'
 require 'chewy/query/loading'
@@ -21,7 +16,17 @@ module Chewy
     include Loading
     include Pagination
 
-    delegate :each, :count, :size, to: :_results
+    RESULT_MERGER = lambda do |key, old_value, new_value|
+      if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+        old_value.merge(new_value, &RESULT_MERGER)
+      elsif new_value.is_a?(Array) && new_value.count > 1
+        new_value
+      else
+        old_value.is_a?(Array) ? new_value : new_value.first
+      end
+    end
+
+    delegate :each, :count, :size, to: :_collection
     alias_method :to_ary, :to_a
 
     attr_reader :index, :options, :criteria
@@ -62,7 +67,7 @@ module Chewy
     #   UsersIndex::User.filter(term: {name: 'Johny'}).explain.first._explanation # => {...}
     #
     def explain value = nil
-      chain { criteria.update_options explain: (value.nil? ? true : value) }
+      chain { criteria.update_request_options explain: (value.nil? ? true : value) }
     end
 
     # Sets query compilation mode for search request.
@@ -207,6 +212,18 @@ module Chewy
       chain { criteria.update_options filter_mode: value }
     end
 
+    # Acts the same way as `filter_mode`, but used for `post_filter`.
+    # Note that it fallbacks by default to `Chewy.filter_mode` if
+    # `Chewy.post_filter_mode` is nil.
+    #
+    #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode(:and)
+    #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode(:should)
+    #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }.post_filter_mode('50%')
+    #
+    def post_filter_mode value
+      chain { criteria.update_options post_filter_mode: value }
+    end
+
     # Sets elasticsearch <tt>size</tt> search request param
     # Default value is set in the elasticsearch and is 10.
     #
@@ -217,7 +234,7 @@ module Chewy
     #          }}
     #
     def limit value
-      chain { criteria.update_options size: Integer(value) }
+      chain { criteria.update_request_options size: Integer(value) }
     end
 
     # Sets elasticsearch <tt>from</tt> search request param
@@ -229,7 +246,23 @@ module Chewy
     #          }}
     #
     def offset value
-      chain { criteria.update_options from: Integer(value) }
+      chain { criteria.update_request_options from: Integer(value) }
+    end
+
+    # Elasticsearch highlight query option support
+    #
+    #   UsersIndex.query(...).highlight(fields: { ... })
+    #
+    def highlight value
+      chain { criteria.update_request_options highlight: value }
+    end
+
+    # Elasticsearch rescore query option support
+    #
+    #   UsersIndex.query(...).rescore(query: { ... })
+    #
+    def rescore value
+      chain { criteria.update_request_options rescore: value }
     end
 
     # Adds facets section to the search request.
@@ -274,6 +307,27 @@ module Chewy
     end
     alias :aggs :aggregations
 
+    # Sets elasticsearch <tt>suggest</tt> search request param
+    #
+    #  UsersIndex.suggest(name: {text: 'Joh', term: {field: 'name'}})
+    #     # => {body: {
+    #            query: {...},
+    #            suggest: {
+    #              text: 'Joh',
+    #              term: {
+    #                field: 'name'
+    #              }
+    #            }
+    #          }}
+    #
+    def suggest params = nil
+      if params
+        chain { criteria.update_suggest params }
+      else
+        _response['suggest'] || {}
+      end
+    end
+
     # Marks the criteria as having zero records. This scope  always returns empty array
     # without touching the elasticsearch server.
     # All the chained calls of methods don't affect the result
@@ -288,6 +342,20 @@ module Chewy
       chain { criteria.update_options none: true }
     end
 
+    # Setups strategy for top-level filtered query
+    #
+    #    UsersIndex.filter { name == 'Johny'}.strategy(:leap_frog)
+    #     # => {body: {
+    #            query: { filtered: {
+    #              filter: { term: { name: 'Johny' } },
+    #              strategy: 'leap_frog'
+    #            } }
+    #          }}
+    #
+    def strategy value = nil
+      chain { criteria.update_options strategy: value }
+    end
+
     # Adds one or more query to the search request
     # Internally queries are stored as an array
     # While the full query compilation this array compiles
@@ -319,7 +387,7 @@ module Chewy
     # While the full query compilation this array compiles
     # according to <tt>:filter_mode</tt> option value
     #
-    # By default it joines inside <tt>and</tt> filter
+    # By default it joins inside <tt>and</tt> filter
     # See <tt>#filter_mode</tt> chainable method for more info.
     #
     # Also this method supports block DSL.
@@ -347,6 +415,37 @@ module Chewy
       chain { criteria.update_filters params }
     end
 
+    # Adds one or more post_filter to the search request
+    # Internally post_filters are stored as an array
+    # While the full query compilation this array compiles
+    # according to <tt>:post_filter_mode</tt> option value
+    #
+    # By default it joins inside <tt>and</tt> filter
+    # See <tt>#post_filter_mode</tt> chainable method for more info.
+    #
+    # Also this method supports block DSL.
+    # See <tt>Chewy::Query::Filters</tt> for more info.
+    #
+    #   UsersIndex.post_filter(term: {name: 'Johny'}).post_filter(range: {age: {lte: 42}})
+    #   UsersIndex::User.post_filter(term: {name: 'Johny'}).post_filter(range: {age: {lte: 42}})
+    #   UsersIndex.post_filter{ name == 'Johny' }.post_filter{ age <= 42 }
+    #     # => {body: {
+    #            post_filter: {and: [{term: {name: 'Johny'}}, {range: {age: {lte: 42}}}]}
+    #          }}
+    #
+    # If only one post_filter was specified, it will become a result
+    # post_filter as is, without joining.
+    #
+    #   UsersIndex.post_filter(term: {name: 'Johny'})
+    #     # => {body: {
+    #            post_filter: {term: {name: 'Johny'}}
+    #          }}
+    #
+    def post_filter params = nil, &block
+      params = Filters.new(&block).__render__ if block
+      chain { criteria.update_post_filters params }
+    end
+
     # Sets search request sorting
     #
     #   UsersIndex.order(:first_name, :last_name).order(age: :desc).order(price: {order: :asc, mode: :avg})
@@ -474,7 +573,7 @@ module Chewy
     end
 
     def reset
-      @_request, @_response, @_results = nil
+      @_request, @_response, @_results, @_collection = nil
     end
 
     def _request
@@ -484,17 +583,32 @@ module Chewy
     def _response
       @_response ||= begin
         ActiveSupport::Notifications.instrument 'search_query.chewy', request: _request, index: index do
-          index.client.search(_request)
+          begin
+            index.client.search(_request)
+          rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
+            raise e if e.message !~ /IndexMissingException/
+            {}
+          end
         end
       end
     end
 
     def _results
-      @_results ||= (criteria.none? ? [] : _response['hits']['hits']).map do |hit|
-        attributes = hit['_source'] || {}
-        attributes.reverse_merge!(id: hit['_id'])
-          .merge!(_score: hit['_score'], _explanation: hit['_explanation'])
-        index.type_hash[hit['_type']].new attributes
+      @_results ||= (criteria.none? || _response == {} ? [] : _response['hits']['hits']).map do |hit|
+        attributes = (hit['_source'] || {}).merge(hit['highlight'] || {}, &RESULT_MERGER)
+        attributes.reverse_merge!(id: hit['_id']).merge!(_score: hit['_score'])
+
+        wrapper = index.type_hash[hit['_type']].new attributes
+        wrapper._data = hit
+        wrapper
+      end
+    end
+
+    def _collection
+      @_collection ||= begin
+        _load_objects! if criteria.options[:preload]
+        criteria.options[:preload] && criteria.options[:loaded_objects] ?
+          _results.map(&:_object) : _results
       end
     end
   end

data/lib/chewy/query/compose.rb

@@ -4,16 +4,26 @@ module Chewy
 
     protected
 
-      def _composed_query queries, filters
-        if filters
-          {query: {
-            filtered: {
-              query: queries ? queries : {match_all: {}},
-              filter: filters
-            }
-          }}
-        elsif queries
-          {query: queries}
+      def _filtered_query query, filter, options = {}
+        query = { match_all: {} } if !query.present? && filter.present?
+
+        if filter.present?
+          filtered = if query.present?
+            { query: { filtered: {
+              query: query,
+              filter: filter
+            } } }
+          else
+            { query: { filtered: {
+              filter: filter
+            } } }
+          end
+          filtered[:query][:filtered].merge!(strategy: options[:strategy].to_s) if options[:strategy].present?
+          filtered
+        elsif query.present?
+          { query: query }
+        else
+          { }
         end
       end
 
@@ -23,14 +33,14 @@ module Chewy
         if queries.many?
           case logic
           when :dis_max
-            {dis_max: {queries: queries}}
+            { dis_max: { queries: queries } }
           when :must, :should
-            {bool: {logic => queries}}
+            { bool: { logic => queries } }
           else
             if logic.is_a?(Float)
-              {dis_max: {queries: queries, tie_breaker: logic}}
+              { dis_max: { queries: queries, tie_breaker: logic } }
             else
-              {bool: {should: queries, minimum_should_match: logic}}
+              { bool: { should: queries, minimum_should_match: logic } }
             end
           end
         else
@@ -44,11 +54,11 @@ module Chewy
         if filters.many?
           case logic
           when :and, :or
-            {logic => filters}
+            { logic => filters }
           when :must, :should
-            {bool: {logic => filters}}
+            { bool: { logic => filters } }
           else
-            {bool: {should: filters, minimum_should_match: logic}}
+            { bool: { should: filters, minimum_should_match: logic } }
           end
         else
           filters.first

data/lib/chewy/query/criteria.rb

@@ -4,12 +4,16 @@ module Chewy
   class Query
     class Criteria
       include Compose
-      ARRAY_STORAGES = [:queries, :filters, :sort, :fields, :types]
-      HASH_STORAGES = [:options, :facets, :aggregations]
+      ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types]
+      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest]
       STORAGES = ARRAY_STORAGES + HASH_STORAGES
 
       def initialize options = {}
-        @options = options.merge(query_mode: Chewy.query_mode, filter_mode: Chewy.filter_mode)
+        @options = options.merge(
+          query_mode: Chewy.query_mode,
+          filter_mode: Chewy.filter_mode,
+          post_filter_mode: Chewy.filter_mode || Chewy.post_filter_mode
+        )
       end
 
       def == other
@@ -40,6 +44,10 @@ module Chewy
         options.merge!(modifer)
       end
 
+      def update_request_options(modifer)
+        request_options.merge!(modifer)
+      end
+
       def update_facets(modifer)
         facets.merge!(modifer)
       end
@@ -48,12 +56,16 @@ module Chewy
         aggregations.merge!(modifer)
       end
 
-      def update_queries(modifer)
-        @queries = queries + Array.wrap(modifer).reject(&:blank?)
+      def update_suggest(modifier)
+        suggest.merge!(modifier)
       end
 
-      def update_filters(modifer)
-        @filters = filters + Array.wrap(modifer).reject(&:blank?)
+      [:filters, :queries, :post_filters].each do |storage|
+        class_eval <<-RUBY
+          def update_#{storage}(modifer)
+            @#{storage} = #{storage} + Array.wrap(modifer).reject(&:blank?)
+          end
+        RUBY
       end
 
       def update_sort(modifer, options = {})
@@ -85,14 +97,17 @@ module Chewy
       end
 
       def request_body
-        body = (_composed_query(_request_query, _request_filter) || {}).tap do |body|
-          body.merge!(facets: facets) if facets?
-          body.merge!(aggregations: aggregations) if aggregations?
-          body.merge!(sort: sort) if sort?
-          body.merge!(_source: fields) if fields?
-        end
+        body = {}
+
+        body.merge!(_filtered_query(_request_query, _request_filter, options.slice(:strategy)))
+        body.merge!(post_filter: _request_post_filter) if post_filters?
+        body.merge!(facets: facets) if facets?
+        body.merge!(aggregations: aggregations) if aggregations?
+        body.merge!(suggest: suggest) if suggest?
+        body.merge!(sort: sort) if sort?
+        body.merge!(_source: fields) if fields?
 
-        {body: body.merge!(_request_options)}
+        { body: body.merge!(request_options) }
       end
 
     protected
@@ -104,17 +119,10 @@ module Chewy
       def initialize_clone(other)
         STORAGES.each do |storage|
           value = other.send(storage)
-          if value
-            value = Marshal.load(Marshal.dump(value))
-            instance_variable_set("@#{storage}", value)
-          end
+          instance_variable_set("@#{storage}", value.deep_dup)
         end
       end
 
-      def _request_options
-        options.slice(:size, :from, :explain, :aggregations)
-      end
-
       def _request_query
         _queries_join(queries, options[:query_mode])
       end
@@ -133,6 +141,10 @@ module Chewy
       def _request_types
         _filters_join(types.map { |type| {type: {value: type}} }, :or)
       end
+
+      def _request_post_filter
+        _filters_join(post_filters, options[:post_filter_mode])
+      end
     end
   end
 end