chewy 0.6.2 → 0.7.0

data/lib/chewy/errors.rb

@@ -11,20 +11,29 @@ module Chewy
   class UnderivableType < Error
   end
 
+  class UndefinedUpdateStrategy < Error
+    def initialize type
+      super <<-MESSAGE
+Index update strategy is undefined in current context.
+Please wrap your code with `Chewy.strategy(:strategy_name) block.`
+      MESSAGE
+    end
+  end
+
   class DocumentNotFound < Error
   end
 
   class ImportFailed < Error
     def initialize type, errors
-      output = "Import failed for `#{type}` with:\n"
+      message = "Import failed for `#{type}` with:\n"
       errors.each do |action, errors|
-        output << "    #{action.to_s.humanize} errors:\n"
+        message << "    #{action.to_s.humanize} errors:\n"
         errors.each do |error, documents|
-          output << "      `#{error}`\n"
-          output << "        on #{documents.count} documents: #{documents}\n"
+          message << "      `#{error}`\n"
+          message << "        on #{documents.count} documents: #{documents}\n"
         end
       end
-      super output
+      super message
     end
   end
 end

data/lib/chewy/fields/base.rb

@@ -20,9 +20,10 @@ module Chewy
         false
       end
 
-      def compose(object)
+      def compose(object, *parent_objects)
         result = if value && value.is_a?(Proc)
-          value.arity == 0 ? object.instance_exec(&value) : value.call(object)
+          value.arity.zero? ? object.instance_exec(&value) :
+            value.call(object, *parent_objects.first(value.arity - 1))
         elsif object.is_a?(Hash)
           object[name] || object[name.to_s]
         else
@@ -30,12 +31,12 @@ module Chewy
         end
 
         result = if result.respond_to?(:to_ary)
-          result.to_ary.map { |object| nested_compose(object) }
+          result.to_ary.map { |result| nested_compose(result, object, *parent_objects) }
         else
-          nested_compose(result)
+          nested_compose(result, object, *parent_objects)
         end if nested.any? && !multi_field?
 
-        {name => result.as_json}
+        {name => result.as_json(root: false)}
       end
 
       def nested(field = nil)
@@ -57,8 +58,8 @@ module Chewy
 
     private
 
-      def nested_compose(value)
-        nested.values.map { |field| field.compose(value) if value }.compact.inject(:merge)
+      def nested_compose(value, *parent_objects)
+        nested.values.map { |field| field.compose(value, *parent_objects) if value }.compact.inject(:merge)
       end
     end
   end

data/lib/chewy/fields/root.rb

@@ -10,7 +10,7 @@ module Chewy
         @id = options.delete(:id) || options.delete(:_id)
         @parent = options.delete(:parent) || options.delete(:_parent)
         @parent_id = options.delete(:parent_id)
-        options.reverse_merge!(value: ->(_){_})
+        options.reverse_merge!(value: ->(_) { _ })
         super(name, options)
         options.delete(:type)
         @dynamic_templates = []
@@ -66,7 +66,7 @@ module Chewy
           parent_id.arity == 0 ? object.instance_exec(&parent_id) : parent_id.call(object)
         end
       end
-      
+
       def compose_id(object)
         if id
           id.arity == 0 ? object.instance_exec(&id) : id.call(object)

data/lib/chewy/index.rb

@@ -34,7 +34,7 @@ module Chewy
       else
         @index_name ||= begin
           build_index_name(
-            name.gsub(/Index\Z/, '').demodulize.underscore,
+            name.sub(/Index\Z/, '').demodulize.underscore,
             prefix: Chewy.configuration[:prefix]
           ) if name
         end
@@ -137,6 +137,12 @@ module Chewy
       self._settings = Chewy::Index::Settings.new params
     end
 
+    # Returns list of public class methods defined in current index
+    #
+    def self.scopes
+      public_methods - Chewy::Index.public_methods - type_names.map(&:to_sym)
+    end
+
   private
 
     def self.build_index_name *args
@@ -156,13 +162,5 @@ module Chewy
     def self.index_params
       [settings_hash, mappings_hash].inject(:merge)
     end
-
-    def self.search_index
-      self
-    end
-
-    def self.search_type
-      type_names
-    end
   end
 end

data/lib/chewy/log_subscriber.rb

@@ -0,0 +1,34 @@
+module Chewy
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def logger
+      Chewy.logger
+    end
+
+    def import_objects(event)
+      render_action('Import', event) { |payload| payload[:import] }
+    end
+
+    def search_query(event)
+      render_action('Search', event) { |payload| payload[:request] }
+    end
+
+    def delete_query(event)
+      render_action('Delete by Query', event) { |payload| payload[:request] }
+    end
+
+    def render_action action, event, &block
+      payload = event.payload
+      description = block.call(payload)
+
+      if description.present?
+        subject = payload[:type].presence || payload[:index]
+        action = "#{subject} #{action} (#{event.duration.round(1)}ms)"
+        action = color(action, GREEN, true)
+
+        debug("  #{action} #{description}")
+      end
+    end
+  end
+end
+
+Chewy::LogSubscriber.attach_to :chewy

data/lib/chewy/query.rb

@@ -1,5 +1,6 @@
 require 'chewy/query/criteria'
 require 'chewy/query/filters'
+require 'chewy/query/scoping'
 require 'chewy/query/loading'
 require 'chewy/query/pagination'
 
@@ -13,6 +14,7 @@ module Chewy
   #
   class Query
     include Enumerable
+    include Scoping
     include Loading
     include Pagination
 
@@ -29,13 +31,14 @@ module Chewy
     delegate :each, :count, :size, to: :_collection
     alias_method :to_ary, :to_a
 
-    attr_reader :index, :options, :criteria
+    attr_reader :_indexes, :_types, :options, :criteria
 
-    def initialize index, options = {}
-      @index, @options = index, options
-      @types = Array.wrap(options.delete(:types))
+    def initialize *indexes_or_types_and_options
+      @options = indexes_or_types_and_options.extract_options!
+      @_types = indexes_or_types_and_options.select { |klass| klass < Chewy::Type }
+      @_indexes = indexes_or_types_and_options.select { |klass| klass < Chewy::Index }
+      @_indexes |= @_types.map(&:index)
       @criteria = Criteria.new
-      reset
     end
 
     # Comparation with other query or collection
@@ -347,21 +350,21 @@ module Chewy
     # added to the search request and combinded according to
     # <tt>boost_mode</tt> and <tt>score_mode</tt>
     #
-    #   UsersIndex.script_score("doc['boost'].value", filter: { term: {foo: :bar} })
+    #   UsersIndex.script_score("doc['boost'].value", params: { modifier: 2 })
     #       # => {body:
     #              query: {
     #                function_score: {
     #                  query: { ...},
     #                  functions: [{
     #                    script_score: {
-    #                       script: "doc['boost'].value"
-    #                     },
-    #                     filter: { term: { foo: :bar } }
+    #                       script: "doc['boost'].value * modifier",
+    #                       params: { modifier: 2 }
+    #                     }
     #                    }
     #                  }]
     #                } } }
     def script_score(script, options = {})
-      scoring = options.merge(script_score: { script: script })
+      scoring = { script_score: { script: script }.merge(options) }
       chain { criteria.update_scores scoring }
     end
 
@@ -800,11 +803,7 @@ module Chewy
     #          }}}}
     #
     def types *params
-      if params.any?
-        chain { criteria.update_types params }
-      else
-        @types
-      end
+      chain { criteria.update_types params }
     end
 
     # Acts the same way as <tt>types</tt>, but cleans up previously set types
@@ -841,8 +840,11 @@ module Chewy
     #
     def delete_all
       request = chain { criteria.update_options simple: true }.send(:_request)
-      ActiveSupport::Notifications.instrument 'delete_query.chewy', request: request, index: index do
-        index.client.delete_by_query(request)
+      ActiveSupport::Notifications.instrument 'delete_query.chewy',
+        request: request, indexes: _indexes, types: _types,
+        index: _indexes.one? ? _indexes.first : _indexes,
+        type: _types.one? ? _types.first : _types do
+          Chewy.client.delete_by_query(request)
       end
     end
 
@@ -899,7 +901,7 @@ module Chewy
   private
 
     def chain &block
-      clone.tap { |q| q.instance_eval(&block) }
+      clone.tap { |q| q.instance_exec(&block) }
     end
 
     def reset
@@ -907,17 +909,20 @@ module Chewy
     end
 
     def _request
-      @_request ||= criteria.request_body.merge(index: index.index_name, type: types)
+      @_request ||= criteria.request_body.merge(index: _indexes.map(&:index_name), type: _types.map(&:type_name))
     end
 
     def _response
-      @_response ||= ActiveSupport::Notifications.instrument 'search_query.chewy', request: _request, index: index do
-        begin
-          index.client.search(_request)
-        rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
-          raise e if e.message !~ /IndexMissingException/
-          {}
-        end
+      @_response ||= ActiveSupport::Notifications.instrument 'search_query.chewy',
+        request: _request, indexes: _indexes, types: _types,
+        index: _indexes.one? ? _indexes.first : _indexes,
+        type: _types.one? ? _types.first : _types do
+          begin
+            Chewy.client.search(_request)
+          rescue Elasticsearch::Transport::Transport::Errors::NotFound => e
+            raise e if e.message !~ /IndexMissingException/
+            {}
+          end
       end
     end
 
@@ -928,7 +933,7 @@ module Chewy
           .merge!(_score: hit['_score'])
           .merge!(_explanation: hit['_explanation'])
 
-        wrapper = index.type_hash[hit['_type']].new attributes
+        wrapper = _derive_index(hit['_index']).type_hash[hit['_type']].new attributes
         wrapper._data = hit
         wrapper
       end
@@ -941,5 +946,14 @@ module Chewy
           _results.map(&:_object) : _results
       end
     end
+
+    def _derive_index index_name
+      (@derive_index ||= {})[index_name] ||= _indexes_hash[index_name] ||
+        _indexes_hash[_indexes_hash.keys.sort_by(&:length).reverse.detect { |name| index_name.starts_with?(name) }]
+    end
+
+    def _indexes_hash
+      @_indexes_hash ||= _indexes.index_by(&:index_name)
+    end
   end
 end

data/lib/chewy/query/criteria.rb

@@ -5,14 +5,14 @@ module Chewy
     class Criteria
       include Compose
       ARRAY_STORAGES = [:queries, :filters, :post_filters, :sort, :fields, :types, :scores]
-      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest]
+      HASH_STORAGES = [:options, :request_options, :facets, :aggregations, :suggest, :script_fields]
       STORAGES = ARRAY_STORAGES + HASH_STORAGES
 
       def initialize options = {}
         @options = options.merge(
           query_mode: Chewy.query_mode,
           filter_mode: Chewy.filter_mode,
-          post_filter_mode: Chewy.filter_mode || Chewy.post_filter_mode
+          post_filter_mode: Chewy.post_filter_mode || Chewy.filter_mode
         )
       end
 
@@ -40,52 +40,56 @@ module Chewy
         !!options[:none]
       end
 
-      def update_options(modifer)
-        options.merge!(modifer)
+      def update_options(modifier)
+        options.merge!(modifier)
       end
 
-      def update_request_options(modifer)
-        request_options.merge!(modifer)
+      def update_request_options(modifier)
+        request_options.merge!(modifier)
       end
 
-      def update_facets(modifer)
-        facets.merge!(modifer)
+      def update_facets(modifier)
+        facets.merge!(modifier)
       end
 
-      def update_scores(modifer)
-        @scores = scores + Array.wrap(modifer).reject(&:blank?)
+      def update_scores(modifier)
+        @scores = scores + Array.wrap(modifier).reject(&:blank?)
       end
 
-      def update_aggregations(modifer)
-        aggregations.merge!(modifer)
+      def update_aggregations(modifier)
+        aggregations.merge!(modifier)
       end
 
       def update_suggest(modifier)
         suggest.merge!(modifier)
       end
 
+      def update_script_fields(modifier)
+        script_fields.merge!(modifier)
+      end
+
       [:filters, :queries, :post_filters].each do |storage|
         class_eval <<-RUBY
-          def update_#{storage}(modifer)
-            @#{storage} = #{storage} + Array.wrap(modifer).reject(&:blank?)
+          def update_#{storage}(modifier)
+            @#{storage} = #{storage} + Array.wrap(modifier).reject(&:blank?)
           end
         RUBY
       end
 
-      def update_sort(modifer, options = {})
+      def update_sort(modifier, options = {})
         @sort = nil if options[:purge]
-        modifer = Array.wrap(modifer).flatten.map do |element|
+        modifier = Array.wrap(modifier).flatten.map do |element|
           element.is_a?(Hash) ? element.map { |k, v| {k => v} } : element
         end.flatten
-        @sort = sort + modifer
+        @sort = sort + modifier
       end
 
       %w(fields types).each do |storage|
-        define_method "update_#{storage}" do |modifer, options = {}|
+        define_method "update_#{storage}" do |modifier, options = {}|
           variable = "@#{storage}"
           instance_variable_set(variable, nil) if options[:purge]
-          modifer = send(storage) | Array.wrap(modifer).flatten.map(&:to_s).reject(&:blank?)
-          instance_variable_set(variable, modifer)
+          modifier = send(storage) | Array.wrap(modifier).flatten.map(&:to_s).reject(&:blank?)
+          instance_variable_set(variable, modifier)
         end
       end
 
@@ -112,6 +116,7 @@ module Chewy
           body.merge!(suggest: suggest) if suggest?
           body.merge!(sort: sort) if sort?
           body.merge!(_source: fields) if fields?
+          body.merge!(script_fields: script_fields) if script_fields?
 
           body = _boost_query(body)
 
@@ -133,14 +138,14 @@ module Chewy
       end
 
       def _boost_query(body)
-        scores? or return body
+        return body unless scores?
         query = body.delete :query
         filter = body.delete :filter
         if query && filter
           query = { filtered: { query: query, filter: filter } }
           filter = nil
         end
-        score = { }
+        score = {}
         score[:functions] = scores
         score[:boost_mode] = options[:boost_mode] if options[:boost_mode]
         score[:score_mode] = options[:score_mode] if options[:score_mode]
@@ -165,7 +170,7 @@ module Chewy
       end
 
       def _request_types
-        _filters_join(types.map { |type| {type: {value: type}} }, :or)
+        _filters_join(types.map { |type| { type: { value: type } } }, :or)
       end
 
       def _request_post_filter

data/lib/chewy/query/scoping.rb

@@ -0,0 +1,20 @@
+module Chewy
+  class Query
+    module Scoping
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def scopes
+          Thread.current[:chewy_scopes] ||= []
+        end
+      end
+
+      def scoping
+        self.class.scopes.push(self)
+        yield
+      ensure
+        self.class.scopes.pop
+      end
+    end
+  end
+end