chewy 0.6.2 → 0.7.0

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

@@ -5,6 +5,8 @@ module Chewy
       class Base
         BATCH_SIZE = 1000
 
+        attr_reader :target, :options
+
         # Camelcased name, used as type class constant name.
         # For returned value 'Product' will be generated class name `ProductsIndex::Product`
         #
@@ -20,6 +22,14 @@ module Chewy
           @type_name ||= name.underscore
         end
 
+        # Returns shortest identifies for further postponed importing.
+        # For ORM/ODM it will be an array of ids for simple objects -
+        # just objects themselves
+        #
+        def identify collection
+          raise NotImplementedError
+        end
+
         # Splits passed objects to groups according to `:batch_size` options.
         # For every group crates hash with action keys. Example:
         #
@@ -40,6 +50,31 @@ module Chewy
         def load *args
           raise NotImplementedError
         end
+
+      private
+
+        def grouped_objects(objects)
+          objects.group_by do |object|
+            delete_from_index?(object) ? :delete : :index
+          end
+        end
+
+        def delete_from_index?(object)
+          if object.respond_to?(:delete_from_index?)
+            ActiveSupport::Deprecation.warn('`delete_from_index?` method in models is deprecated and will be removed soon. Use per-type `delete_if` option for `define_type`')
+            delete = object.delete_from_index?
+          end
+
+          delete_if = options[:delete_if]
+          delete ||= case delete_if
+          when Symbol, String
+            object.send delete_if
+          when Proc
+            delete_if.arity == 1 ? delete_if.call(object) : object.instance_exec(&delete_if)
+          end
+
+          !!delete
+        end
       end
     end
   end

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

@@ -1,145 +1,45 @@
-require 'chewy/type/adapter/base'
+require 'chewy/type/adapter/orm'
 
 module Chewy
   class Type
     module Adapter
-      class Mongoid < Base
-        def initialize *args
-          @options = args.extract_options!
-          subject = args.first
-          if subject.is_a?(::Mongoid::Criteria)
-            @model = subject.klass
-            @scope = subject
-          else
-            @model = subject
-          end
-        end
-
-        def name
-          @name ||= (options[:name].present? ? options[:name].to_s.camelize : model.model_name.to_s).demodulize
-        end
-
-        # Import method for Mongoid takes import data and import options
-        #
-        # Import data types:
-        #
-        #   * Nothing passed - imports all the model data
-        #   * ActiveRecord scope
-        #   * Objects collection
-        #   * Ids collection
-        #
-        # Import options:
-        #
-        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
-        #
-        # Method handles destroyed objects as well. In case of objects AcriveRecord::Relation
-        # or array passed, objects, responding with true to `destroyed?` method will be deleted
-        # from index. In case of ids array passed - documents with missing records ids will be
-        # deleted from index:
-        #
-        #   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
-          batch_size = import_options[:batch_size]
-
-          collection = args.none? ? model_all :
-            (args.one? && args.first.is_a?(::Mongoid::Criteria) ? args.first : args.flatten.compact)
+      class Mongoid < Orm
+      private
 
-          if collection.is_a?(::Mongoid::Criteria)
-            result = true
-            merged_scope(collection).batch_size(batch_size).no_timeout.each_slice(batch_size) do |batch|
-              result &= block.call grouped_objects(batch)
-            end
-            result
-          else
-            if collection.all? { |object| object.respond_to?(:id) }
-              collection.each_slice(batch_size).map do |group|
-                block.call grouped_objects(group)
-              end.all?
-            else
-              import_ids(collection, import_options, &block)
-            end
+        def cleanup_default_scope!
+          if Chewy.logger && @default_scope.options.values_at(:sort, :limit, :skip).compact.present?
+            Chewy.logger.warn('Default type scope order, limit and offest are ignored and will be nullified')
           end
-        end
-
-        def load *args
-          load_options = args.extract_options!
-          objects = args.flatten
-
-          additional_scope = load_options[load_options[:_type].type_name.to_sym].try(:[], :scope) || load_options[:scope]
 
-          scope = scoped_model(objects.map(&:id))
-          loaded_objects = if additional_scope.is_a?(Proc)
-            scope.instance_exec(&additional_scope)
-          elsif additional_scope.is_a?(::Mongoid::Criteria)
-            scope.merge(additional_scope)
-          else
-            scope
-          end.index_by { |object| object.id.to_s }
-
-          objects.map { |object| loaded_objects[object.id.to_s] }
+          @default_scope = @default_scope.reorder(nil)
+          @default_scope.options.delete(:limit)
+          @default_scope.options.delete(:skip)
         end
 
-      private
-
-        attr_reader :model, :scope, :options
-
-        def import_ids(ids, import_options = {}, &block)
-          ids.uniq!
-          batch_size = import_options[:batch_size] || BATCH_SIZE
-
-          indexed = true
-          merged_scope(scoped_model(ids)).batch_size(batch_size).no_timeout.each_slice(batch_size) do |batch|
-            ids -= batch.map(&:id)
-            indexed &= block.call(grouped_objects(batch))
-          end
-
-          deleted = ids.each_slice(batch_size).map do |group|
-            block.call(delete: group)
+        def import_scope(scope, batch_size)
+          scope.batch_size(batch_size).no_timeout.pluck(:_id).each_slice(batch_size).map do |ids|
+            yield grouped_objects(default_scope_where_ids_in(ids))
           end.all?
+        end
 
-          indexed && deleted
+        def pluck_ids(scope)
+          scope.pluck(:_id)
         end
 
-        def grouped_objects(objects)
-          objects.group_by do |object|
-            delete = object.delete_from_index? if object.respond_to?(:delete_from_index?)
-            delete ||= object.destroyed?
-            delete ? :delete : :index
-          end
+        def scope_where_ids_in(scope, ids)
+          scope.where(:_id.in => ids)
         end
 
-        def merged_scope(target)
-          scope ? scope.clone.merge(target) : target
+        def all_scope
+          target.all
         end
 
-        def scoped_model(ids)
-          model.where(:_id.in => ids)
+        def relation_class
+          ::Mongoid::Criteria
         end
 
-        def model_all
-          model.all
+        def object_class
+          ::Mongoid::Document
         end
       end
     end

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

@@ -10,7 +10,11 @@ module Chewy
         end
 
         def name
-          @name ||= (options[:name] || target).to_s.camelize.demodulize
+          @name ||= (options[:name] || @target).to_s.camelize.demodulize
+        end
+
+        def identify collection
+          Array.wrap(collection)
         end
 
         # Imports passed data with options
@@ -23,31 +27,30 @@ 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.
+        # If method `destroyed?` is defined for object and returns true or object
+        # satisfy `delete_if` type option 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
-          objects = args.flatten.compact
 
-          objects.each_slice(batch_size).map do |group|
-            action_groups = group.group_by do |object|
-              raise "Object is not a `#{target}`" if class_target? && !object.is_a?(target)
-              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?
+          objects = args.empty? && @target.respond_to?(import_all_method) ?
+            @target.send(import_all_method) : args.flatten.compact
+
+          import_objects(objects, batch_size, &block)
         end
 
         def load *args
           load_options = args.extract_options!
           objects = args.flatten
-          if class_target?
+          if target.respond_to?(load_all_method)
+            target.send(load_all_method, objects)
+          elsif target.respond_to?(load_one_method)
+            objects.map { |object| target.send(load_one_method, object) }
+          elsif target.respond_to?(:wrap)
+            ActiveSupport::Deprecation.warn('Loading with `wrap` method is deprecated. Rename it to `load_one` or pass `load_one_method: :my_load_method` option to `define_type`')
             objects.map { |object| target.wrap(object) }
           else
             objects
@@ -56,10 +59,29 @@ module Chewy
 
       private
 
-        attr_reader :target, :options
+        def import_objects(objects, batch_size)
+          objects.each_slice(batch_size).map do |group|
+            yield grouped_objects(group)
+          end.all?
+        end
+
+        def delete_from_index?(object)
+          delete = super
+          delete ||= object.destroyed? if object.respond_to?(:destroyed?)
+          delete ||= object[:_destroyed] || object['_destroyed'] if object.is_a?(Hash)
+          !!delete
+        end
+
+        def import_all_method
+          @import_all_method ||= options[:import_all_method] || :call
+        end
+
+        def load_all_method
+          @load_all_method ||= options[:load_all_method] || :load_all
+        end
 
-        def class_target?
-          @class_target ||= @target.is_a?(Class)
+        def load_one_method
+          @load_one_method ||= options[:load_one_method] || :load_one
         end
       end
     end

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

@@ -0,0 +1,142 @@
+require 'chewy/type/adapter/base'
+
+module Chewy
+  class Type
+    module Adapter
+      class Orm < Base
+        attr_reader :default_scope
+
+        def initialize *args
+          @options = args.extract_options!
+          class_or_relation = args.first
+          if class_or_relation.is_a?(relation_class)
+            @target = class_or_relation.klass
+            @default_scope = class_or_relation
+          else
+            @target = class_or_relation
+            @default_scope = all_scope
+          end
+          cleanup_default_scope!
+        end
+
+        def name
+          @name ||= (options[:name].present? ? options[:name].to_s.camelize : target.model_name.to_s).demodulize
+        end
+
+        def identify collection
+          ids = if collection.is_a?(relation_class)
+            pluck_ids(collection)
+          else
+            Array.wrap(collection).map do |entity|
+              entity.is_a?(object_class) ? entity.id : entity
+            end
+          end
+        end
+
+        # Import method for ORM takes import data and import options
+        #
+        # Import data types:
+        #
+        #   * Nothing passed - imports all the model data according to type
+        #     default scope
+        #   * ORM scope
+        #   * Objects collection
+        #   * Ids collection
+        #
+        # Import options:
+        #
+        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
+        #
+        # Method handles destroyed objects as well. In case of objects ORM scope
+        # or array passed, objects, responding with true to `destroyed?` method will be deleted
+        # from index. In case of ids array passed - documents with missing records ids will be
+        # deleted from index:
+        #
+        #   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 type option `delete_if`. It it returns `true`
+        # object will be deleted from index. Note that if this option is defined and
+        # return `false` Chewy will still check `destroyed?` method. This is useful
+        # for paranoid objects deleting implementation.
+        #
+        #   define_type User, delete_if: ->{ deleted_at } do
+        #     ...
+        #   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!
+          batch_size = import_options[:batch_size] || BATCH_SIZE
+
+          collection = args.empty? ? default_scope :
+            (args.one? && args.first.is_a?(relation_class) ? args.first : args.flatten.compact)
+
+          if collection.is_a?(relation_class)
+            import_scope(collection, batch_size, &block)
+          else
+            import_objects(collection, batch_size, &block)
+          end
+        end
+
+        def load *args
+          load_options = args.extract_options!
+          objects = args.flatten
+
+          additional_scope = load_options[load_options[:_type].type_name.to_sym].try(:[], :scope) || load_options[:scope]
+
+          scope = all_scope_where_ids_in(objects.map(&:id))
+          loaded_objects = if additional_scope.is_a?(Proc)
+            scope.instance_exec(&additional_scope)
+          elsif additional_scope.is_a?(relation_class)
+            scope.merge(additional_scope)
+          else
+            scope
+          end.index_by { |object| object.id.to_s }
+
+          objects.map { |object| loaded_objects[object.id.to_s] }
+        end
+
+      private
+
+        def import_objects(collection, batch_size)
+          hash = collection.index_by do |entity|
+            entity.is_a?(object_class) ? entity.id : entity
+          end
+
+          indexed = hash.keys.each_slice(batch_size).map do |ids|
+            batch = default_scope_where_ids_in(ids)
+            if batch.empty?
+              true
+            else
+              batch.each { |object| hash.delete(object.id) }
+              yield grouped_objects(batch)
+            end
+          end.all?
+
+          deleted = hash.keys.each_slice(batch_size).map do |group|
+            yield delete: hash.values_at(*group)
+          end.all?
+
+          indexed && deleted
+        end
+
+        def default_scope_where_ids_in(ids)
+          scope_where_ids_in(default_scope, ids)
+        end
+
+        def all_scope_where_ids_in(ids)
+          scope_where_ids_in(all_scope, ids)
+        end
+      end
+    end
+  end
+end