chewy 0.4.1 → 0.5.0

data/lib/chewy/query/loading.rb

@@ -3,24 +3,108 @@ module Chewy
     module Loading
       extend ActiveSupport::Concern
 
+      # Lazily loads actual ORM/ODM objects for search result.
+      # Returns scope marked to return loaded objects array instead of
+      # chewy wrappers. In case when object can not be loaded because it
+      # was deleted or don't satisfy given scope or options - the
+      # result collection will contain nil value in the place of this
+      # object. Use `compact` method to avoid this if necessary.
+      #
+      #   UsersIndex.query(...).load #=> [#<User id: 42...>, ...]
+      #   UsersIndex.query(...).load.filter(...) #=> [#<User id: 42...>, ...]
+      #
+      # Possible options:
+      #
+      #   <tt>:scope</tt> - used to give a scope for _every_ loaded type.
+      #
+      #       PlacesIndex.query(...).load(scope: ->{ includes(:testimonials) })
+      #
+      #     If places here contain cities and countries then preload will be
+      #     done like this:
+      #
+      #       City.where(id: [...]).includes(:testimonials)
+      #       Country.where(id: [...]).includes(:testimonials)
+      #
+      #     It is also possible to pass own scope for every loaded type:
+      #
+      #       PlacesIndex.query(...).load(
+      #         city: { scope: ->{ includes(:testimonials, :country) }}
+      #         country: { scope: ->{ includes(:testimonials, :cities) }}
+      #       )
+      #
+      #     And loading will be performed as:
+      #
+      #       City.where(id: [...]).includes(:testimonials, :country)
+      #       Country.where(id: [...]).includes(:testimonials, :cities)
+      #
+      #     In case of ActiveRecord objects loading the same result
+      #     will be reached using ActiveRecord scopes instead of
+      #     lambdas. But it works only with per-type scopes,
+      #     and doesn't work with the common scope.
+      #
+      #       PlacesIndex.query(...).load(
+      #         city: { scope: City.includes(:testimonials, :country) }
+      #         country: { scope: Country.includes(:testimonials, :cities) }
+      #       )
+      #
+      #   <tt>:only</tt> - loads objects for the specified types
+      #
+      #     PlacesIndex.query(...).load(only: :city)
+      #     PlacesIndex.query(...).load(only: [:city])
+      #     PlacesIndex.query(...).load(only: [:city, :country])
+      #
+      #   <tt>:except</tt> - doesn't load listed types
+      #
+      #     PlacesIndex.query(...).load(except: :city)
+      #     PlacesIndex.query(...).load(except: [:city])
+      #     PlacesIndex.query(...).load(except: [:city, :country])
+      #
       def load(options = {})
-        if defined?(::Kaminari)
-          ::Kaminari.paginate_array(_load_objects(options),
-            limit: limit_value, offset: offset_value, total_count: total_count)
-        else
-          _load_objects(options)
-        end
+        chain { criteria.update_options preload: options, loaded_objects: true }
+      end
+
+      # This methods is just convenient way to preload some ORM/ODM
+      # objects and continue to work with Chewy wrappers. Returns
+      # Chewy query scope. Note that `load` method performs ES request
+      # so preload method should also be the last in scope methods chain.
+      # Takes the same options as the `load` method
+      #
+      #   PlacesIndex.query(...).preload(only: :city)
+      #
+      # Loaded objects are also attached to corresponding Chewy
+      # type wrapper objects and available with `_object` accessor.
+      #
+      #    scope = PlacesIndex.query(...)
+      #    preload_scope = scope.preload
+      #    preload_scope.first #=> PlacesIndex::City wrapper instance
+      #    preload_scope.first._object #=> City model instance
+      #    scope.load == preload_scope.map(&:_object) #=> true
+      #
+      def preload(options = {})
+        chain { criteria.update_options preload: options, loaded_objects: false }
       end
 
     private
 
-      def _load_objects(options)
+      def _load_objects!
+        options = criteria.options[:preload]
+        only = Array.wrap(options[:only]).map(&:to_s)
+        except = Array.wrap(options[:except]).map(&:to_s)
+
         loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
+          next if except.include?(type.type_name)
+          next if only.any? && !only.include?(type.type_name)
+
           loaded = type.adapter.load(objects, options.merge(_type: type))
-          [type, loaded.index_by.with_index { |loaded, i| objects[i] }]
-        end]
+          [type, loaded.index_by.with_index do |loaded, i|
+            objects[i]._object = loaded
+            objects[i]
+          end]
+        end.compact]
 
-        _results.map { |result| loaded_objects[result.class][result] }
+        _results.map do |result|
+          loaded_objects[result.class][result] if loaded_objects[result.class]
+        end
       end
     end
   end

data/lib/chewy/query/nodes/exists.rb

@@ -12,7 +12,7 @@ module Chewy
         end
 
         def __render__
-          {exists: {term: @name}}
+          {exists: {field: @name}}
         end
       end
     end

data/lib/chewy/query/nodes/has_relation.rb

@@ -50,7 +50,7 @@ module Chewy
           body = if filters && !queries
             {filter: filters}
           else
-            _composed_query(queries, filters)
+            _filtered_query(queries, filters)
           end || {}
 
           {_relation => body.merge(type: @type)} if body

data/lib/chewy/query/nodes/missing.rb

@@ -12,7 +12,7 @@ module Chewy
         end
 
         def __render__
-          {missing: {term: @name}.merge(@options.slice(:existence, :null_value))}
+          {missing: {field: @name}.merge(@options.slice(:existence, :null_value))}
         end
       end
     end

data/lib/chewy/query/pagination.rb

@@ -1,45 +1,15 @@
 module Chewy
   class Query
     module Pagination
-      extend ActiveSupport::Concern
-
-      included do
-        include Kaminari if defined?(::Kaminari)
-      end
-
-      module Kaminari
-        extend ActiveSupport::Concern
-
-        included do
-          include ::Kaminari::PageScopeMethods
-
-          delegate :default_per_page, :max_per_page, :max_pages, to: :_kaminari_config
-
-          class_eval <<-METHOD, __FILE__, __LINE__ + 1
-            def #{::Kaminari.config.page_method_name}(num = 1)
-              limit(limit_value).offset(limit_value * ([num.to_i, 1].max - 1))
-            end
-          METHOD
-        end
-
-        def total_count
-          _response['hits']['total']
-        end
-
-        def limit_value
-          (criteria.options[:size].presence || default_per_page).to_i
-        end
-
-        def offset_value
-          criteria.options[:from].to_i
-        end
-
-      private
-
-        def _kaminari_config
-          ::Kaminari.config
-        end
+      # Returns request total found documents count
+      #
+      #   PlacesIndex.query(...).filter(...).total_count
+      #
+      def total_count
+        _response['hits'].try(:[], 'total') || 0
       end
     end
   end
 end
+
+require 'chewy/query/pagination/kaminari' if defined?(::Kaminari)

data/lib/chewy/query/pagination/kaminari.rb

@@ -0,0 +1,37 @@
+module Chewy
+  class Query
+    module Pagination
+      module Kaminari
+        extend ActiveSupport::Concern
+
+        included do
+          include ::Kaminari::PageScopeMethods
+
+          delegate :default_per_page, :max_per_page, :max_pages, to: :_kaminari_config
+
+          class_eval <<-METHOD, __FILE__, __LINE__ + 1
+            def #{::Kaminari.config.page_method_name}(num = 1)
+              limit(limit_value).offset(limit_value * ([num.to_i, 1].max - 1))
+            end
+          METHOD
+        end
+
+        def limit_value
+          (criteria.request_options[:size].presence || default_per_page).to_i
+        end
+
+        def offset_value
+          criteria.request_options[:from].to_i
+        end
+
+      private
+
+        def _kaminari_config
+          ::Kaminari.config
+        end
+      end
+    end
+  end
+end
+
+Chewy::Query::Pagination.send :include, Chewy::Query::Pagination::Kaminari

data/lib/chewy/runtime.rb

@@ -0,0 +1,9 @@
+require 'chewy/runtime/version'
+
+module Chewy
+  module Runtime
+    def self.version
+      Thread.current[:chewy_runtime_version] ||= Version.new(Chewy.client.info['version']['number'])
+    end
+  end
+end

data/lib/chewy/runtime/version.rb

@@ -0,0 +1,25 @@
+module Chewy
+  module Runtime
+    class Version
+      include Comparable
+      attr_reader :major, :minor, :patch
+
+      def initialize version
+        @major, @minor, @patch = *(version.to_s.split('.', 3) + [0]*3).first(3).map(&:to_i)
+      end
+
+      def to_s
+        [major, minor, patch].join('.')
+      end
+
+      def <=> other
+        other = self.class.new(other) unless other.is_a?(self.class)
+        [
+          major <=> other.major,
+          minor <=> other.minor,
+          patch <=> other.patch
+        ].detect { |c| c != 0 } || 0
+      end
+    end
+  end
+end

data/lib/chewy/type/adapter/active_record.rb

@@ -16,11 +16,7 @@ module Chewy
         end
 
         def name
-          @name ||= options[:name].present? ? options[:name].to_s.camelize : model.model_name.to_s
-        end
-
-        def type_name
-          @type_name ||= (options[:name].presence || model.model_name).to_s.underscore
+          @name ||= (options[:name].present? ? options[:name].to_s.camelize : model.model_name.to_s).demodulize
         end
 
         # Import method fo ActiveRecord takes import data and import options
@@ -44,8 +40,24 @@ module Chewy
         #   users = User.all
         #   users.each { |user| user.destroy if user.incative? }
         #   UsersIndex::User.import users # inactive users will be deleted from index
+        #   # or
         #   UsersIndex::User.import users.map(&:id) # deleted user ids will be deleted from index
         #
+        # Also there is custom API method `delete_from_index?`. It it returns `true`
+        # object will be deleted from index. Note that if this method is defined and
+        # return `false` Chewy will still check `destroyed?` method. This is useful
+        # for paranoid objects sdeleting implementation.
+        #
+        #   class User
+        #     alias_method :delete_from_index?, :deleted_at?
+        #   end
+        #
+        #   users = User.all
+        #   users.each { |user| user.deleted_at = Time.now }
+        #   UsersIndex::User.import users # paranoid deleted users will be deleted from index
+        #   # or
+        #   UsersIndex::User.import users.map(&:id) # user ids will be deleted from index
+        #
         def import *args, &block
           import_options = args.extract_options!
           import_options[:batch_size] ||= BATCH_SIZE
@@ -97,7 +109,7 @@ module Chewy
           indexed = true
           merged_scope(scoped_model(ids)).find_in_batches(import_options.slice(:batch_size)) do |objects|
             ids -= objects.map(&:id)
-            indexed &= block.call index: objects
+            indexed &= block.call(grouped_objects(objects))
           end
 
           deleted = ids.in_groups_of(import_options[:batch_size], false).map do |group|
@@ -109,7 +121,9 @@ module Chewy
 
         def grouped_objects(objects)
           objects.group_by do |object|
-            object.destroyed? ? :delete : :index
+            delete = object.delete_from_index? if object.respond_to?(:delete_from_index?)
+            delete ||= object.destroyed?
+            delete ? :delete : :index
           end
         end
 

data/lib/chewy/type/adapter/base.rb

@@ -17,7 +17,7 @@ module Chewy
         # `ProductsIndex.type_hash['product']` or `ProductsIndex.product`
         #
         def type_name
-          raise NotImplementedError
+          @type_name ||= name.underscore
         end
 
         # Splits passed objects to groups according to `:batch_size` options.

data/lib/chewy/type/adapter/object.rb

@@ -10,11 +10,7 @@ module Chewy
         end
 
         def name
-          @name ||= (options[:name] || target).to_s.camelize
-        end
-
-        def type_name
-          @type_name ||= (options[:name] || target).to_s.underscore
+          @name ||= (options[:name] || target).to_s.camelize.demodulize
         end
 
         # Imports passed data with options
@@ -27,6 +23,11 @@ module Chewy
         #
         #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
         #
+        # If methods `delete_from_index?` or `destroyed?` are defined for object
+        # and any return true then object will be deleted from index. But to be
+        # destroyed objects need to respond to `id` method as well, so ElasticSearch
+        # could know which one to delete.
+        #
         def import *args, &block
           import_options = args.extract_options!
           batch_size = import_options.delete(:batch_size) || BATCH_SIZE
@@ -35,7 +36,9 @@ module Chewy
           objects.in_groups_of(batch_size, false).map do |group|
             action_groups = group.group_by do |object|
               raise "Object is not a `#{target}`" if class_target? && !object.is_a?(target)
-              object.respond_to?(:destroyed?) && object.destroyed? ? :delete : :index
+              delete = object.delete_from_index? if object.respond_to?(:delete_from_index?)
+              delete ||= object.destroyed? if object.respond_to?(:destroyed?)
+              delete ? :delete : :index
             end
             block.call action_groups
           end.all?

data/lib/chewy/type/import.rb

@@ -15,6 +15,8 @@ module Chewy
         #   UsersIndex::User.import suffix: Time.now.to_i    # imports data to index with specified suffix if such is exists
         #   UsersIndex::User.import batch_size: 300          # import batch size
         #
+        # See adapters documentation for more details.
+        #
         def import *args
           import_options = args.extract_options!
           bulk_options = import_options.reject { |k, v| ![:refresh, :suffix].include?(k) }.reverse_merge!(refresh: true)
@@ -34,7 +36,7 @@ module Chewy
         end
 
         # Perform import operation for specified documents.
-        # Raises Chewy::FailedImport exception in case of import errors.
+        # Raises Chewy::ImportFailed exception in case of import errors.
         #
         #   UsersIndex::User.import!                          # imports default data set
         #   UsersIndex::User.import! User.active              # imports active users
@@ -44,6 +46,8 @@ module Chewy
         #   UsersIndex::User.import! suffix: Time.now.to_i    # imports data to index with specified suffix if such is exists
         #   UsersIndex::User.import! batch_size: 300          # import batch size
         #
+        # See adapters documentation for more details.
+        #
         def import! *args
           errors = nil
           subscriber = ActiveSupport::Notifications.subscribe('import_objects.chewy') do |*args|
@@ -51,7 +55,7 @@ module Chewy
           end
           import *args
           ActiveSupport::Notifications.unsubscribe(subscriber)
-          raise Chewy::FailedImport.new(self, errors) if errors.present?
+          raise Chewy::ImportFailed.new(self, errors) if errors.present?
           true
         end
 
@@ -60,9 +64,8 @@ module Chewy
         def bulk options = {}
           suffix = options.delete(:suffix)
 
-          Chewy.wait_for_status
-
           result = client.bulk options.merge(index: index.build_index_name(suffix: suffix), type: type_name)
+          Chewy.wait_for_status
 
           extract_errors result
         end

data/lib/chewy/type/mapping.rb

@@ -82,14 +82,14 @@ module Chewy
         # will be an array of hashes, if `user.quiz` is not a collection association
         # then just values hash will be put in the index.
         #
-        #   field :quiz, type: 'object' do
+        #   field :quiz do
         #     field :question, :answer
         #     field :score, type: 'integer'
         #   end
         #
         # Nested fields are composed from nested objects:
         #
-        #   field :name, type: 'object', value: -> { name_translations } do
+        #   field :name, value: -> { name_translations } do
         #     field :ru, value: ->(name) { name['ru'] }
         #     field :en, value: ->(name) { name['en'] }
         #   end
@@ -99,12 +99,12 @@ module Chewy
         #
         #   field :name, type: 'object', value: -> { name_translations }
         #
-        # The special case is `multi_field`. In that case field composition
-        # changes satisfy elasticsearch rules:
+        # The special case is multi_field. If type options and block are
+        # both present field is treated as a multi-field. In that case field
+        # composition changes satisfy elasticsearch rules:
         #
-        #   field :full_name, type: 'multi_field', value: ->{ full_name.try(:strip) } do
-        #     field :full_name, index: 'analyzed', analyzer: 'name'
-        #     field :sorted, index: 'analyzed', analyzer: 'sorted'
+        #   field :full_name, type: 'string', analyzer: 'name', value: ->{ full_name.try(:strip) } do
+        #     field :sorted, analyzer: 'sorted'
         #   end
         #
         def field *args, &block
@@ -114,7 +114,7 @@ module Chewy
           if args.size > 1
             args.map { |name| field(name, options) }
           else
-            expand_nested(Chewy::Fields::Default.new(args.first, options), &block)
+            expand_nested(Chewy::Fields::Base.new(args.first, options), &block)
           end
         end
 
@@ -135,7 +135,7 @@ module Chewy
         #   template 'title.*', mapping_hash # dot in template causes "path_match" using
         #   template /tit.+/, mapping_hash # using "match_pattern": "regexp"
         #   template /title\..+/, mapping_hash # "\." - escaped dot causes "path_match" using
-        #   template /tit.+/, 'string' mapping_hash # "match_mapping_type" as the optionsl second argument
+        #   template /tit.+/, 'string', mapping_hash # "match_mapping_type" as the optionsl second argument
         #   template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is
         #
         def template *args