chewy 0.8.4 → 7.3.4

data/lib/chewy/strategy/resque.rb

@@ -1,26 +0,0 @@
-module Chewy
-  class Strategy
-    # The strategy works the same way as atomic, but performs
-    # async index update driven by resque
-    #
-    #   Chewy.strategy(:resque) do
-    #     User.all.map(&:save) # Does nothing here
-    #     Post.all.map(&:save) # And here
-    #     # It imports all the changed users and posts right here
-    #   end
-    #
-    class Resque < Atomic
-      class Worker
-        @queue = :chewy
-
-        def self.perform(type, ids, options = {})
-          type.constantize.import!(ids, options)
-        end
-      end
-
-      def leave
-        @stash.all? { |type, ids| ::Resque.enqueue(Chewy::Strategy::Resque::Worker, type.name, ids) }
-      end
-    end
-  end
-end

data/lib/chewy/type/actions.rb

@@ -1,19 +0,0 @@
-module Chewy
-  class Type
-    module Actions
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        # Delete all documents of a type and reimport them
-        # Returns true or false depending on success.
-        #
-        #   UsersIndex::User.reset
-        #
-        def reset
-          delete_all
-          import
-        end
-      end
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require 'chewy/type/adapter/orm'
-
-module Chewy
-  class Type
-    module Adapter
-      class ActiveRecord < Orm
-
-        def self.accepts?(target)
-          defined?(::ActiveRecord::Base) && (
-            target.is_a?(Class) && target < ::ActiveRecord::Base ||
-            target.is_a?(::ActiveRecord::Relation))
-        end
-
-      private
-
-        def cleanup_default_scope!
-          if Chewy.logger && (@default_scope.arel.orders.present? ||
-             @default_scope.arel.limit.present? || @default_scope.arel.offset.present?)
-            Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
-          end
-
-          @default_scope = @default_scope.reorder(nil).limit(nil).offset(nil)
-        end
-
-        def import_scope(scope, batch_size)
-          scope = scope.reorder(target_id.asc).limit(batch_size)
-
-          ids = pluck_ids(scope)
-          result = true
-
-          while ids.present?
-            result &= yield grouped_objects(default_scope_where_ids_in(ids))
-            break if ids.size < batch_size
-            ids = pluck_ids(scope.where(target_id.gt(ids.last)))
-          end
-
-          result
-        end
-
-        def target_id
-          target.arel_table[target.primary_key]
-        end
-
-        def pluck_ids(scope)
-          scope.except(:includes).uniq.pluck(target.primary_key.to_sym)
-        end
-
-        def scope_where_ids_in(scope, ids)
-          scope.where(target_id.in(Array.wrap(ids)))
-        end
-
-        def relation_class
-          ::ActiveRecord::Relation
-        end
-
-        def object_class
-          ::ActiveRecord::Base
-        end
-      end
-
-      module Rails5
-        def pluck_ids(scope)
-          scope.except(:includes).distinct.pluck(target.primary_key.to_sym)
-        end
-      end
-
-      if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 5
-        Chewy::Type::Adapter::ActiveRecord.prepend(Rails5)
-      end
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-require 'chewy/type/adapter/orm'
-
-module Chewy
-  class Type
-    module Adapter
-      class Mongoid < Orm
-
-        def self.accepts?(target)
-          defined?(::Mongoid::Document) && (
-            target.is_a?(Class) && target.ancestors.include?(::Mongoid::Document) ||
-            target.is_a?(::Mongoid::Criteria))
-        end
-
-        def identify collection
-          super(collection).map { |id| id.is_a?(BSON::ObjectId) ? id.to_s : id }
-        end
-
-      private
-
-        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 offset are ignored and will be nullified')
-          end
-
-          @default_scope.options.delete(:limit)
-          @default_scope.options.delete(:skip)
-          @default_scope = @default_scope.reorder(nil)
-        end
-
-        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
-
-        def pluck_ids(scope)
-          scope.pluck(:_id)
-        end
-
-        def scope_where_ids_in(scope, ids)
-          scope.where(:_id.in => ids)
-        end
-
-        def all_scope
-          target.all
-        end
-
-        def relation_class
-          ::Mongoid::Criteria
-        end
-
-        def object_class
-          ::Mongoid::Document
-        end
-      end
-    end
-  end
-end

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

@@ -1,89 +0,0 @@
-require 'chewy/type/adapter/base'
-
-module Chewy
-  class Type
-    module Adapter
-      class Object < Base
-        def initialize *args
-          @options = args.extract_options!
-          @target = args.first
-        end
-
-        def name
-          @name ||= (options[:name] || @target).to_s.camelize.demodulize
-        end
-
-        def identify collection
-          Array.wrap(collection)
-        end
-
-        # Imports passed data with options
-        #
-        # Import data types:
-        #
-        #   * Array ob objects
-        #
-        # Import options:
-        #
-        #   <tt>:batch_size</tt> - import batch size, 1000 objects by default
-        #
-        # 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.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 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
-          end
-        end
-
-      private
-
-        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 load_one_method
-          @load_one_method ||= options[:load_one_method] || :load_one
-        end
-      end
-    end
-  end
-end

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

@@ -1,156 +0,0 @@
-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 = model_of_relation(class_or_relation)
-            @default_scope = class_or_relation
-          else
-            @target = class_or_relation
-            @default_scope = all_scope
-          end
-          cleanup_default_scope!
-        end
-
-        def name
-          @name ||= (options[:name].presence || target.name).to_s.camelize.demodulize
-        end
-
-        def identify collection
-          if collection.is_a?(relation_class)
-            pluck_ids(collection)
-          else
-            Array.wrap(collection).map do |entity|
-              entity.is_a?(object_class) ? entity.public_send(primary_key) : 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.inactive? }
-        #   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(&primary_key))
-          loaded_objects = load_scope_objects(scope, additional_scope).index_by { |object| object.public_send(primary_key).to_s }
-
-          objects.map { |object| loaded_objects[object.public_send(primary_key).to_s] }
-        end
-
-      private
-
-        def import_objects(collection, batch_size)
-          hash = Hash[identify(collection).zip(collection)]
-
-          indexed = hash.keys.each_slice(batch_size).map do |ids|
-            batch = default_scope_where_ids_in(ids)
-            if batch.empty?
-              true
-            else
-              identify(batch).each { |id| hash.delete(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 primary_key
-          :id
-        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
-
-        def all_scope
-          target.where(nil)
-        end
-
-        def model_of_relation relation
-          relation.klass
-        end
-
-        def load_scope_objects(scope, additional_scope = nil)
-          if additional_scope.is_a?(Proc)
-            scope.instance_exec(&additional_scope)
-          elsif additional_scope.is_a?(relation_class) && scope.respond_to?(:merge)
-            scope.merge(additional_scope)
-          else
-            scope
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-require 'chewy/type/adapter/base'
-
-module Chewy
-  class Type
-    module Adapter
-      class Sequel < Orm
-        attr_reader :default_scope
-        alias_method :default_dataset, :default_scope
-
-        def self.accepts?(target)
-          defined?(::Sequel::Model) && (
-            target.is_a?(Class) && target < ::Sequel::Model ||
-            target.is_a?(::Sequel::Dataset))
-        end
-
-      private
-
-        def cleanup_default_scope!
-          if Chewy.logger && @default_scope != @default_scope.unordered.unlimited
-            Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified')
-          end
-
-          @default_scope = @default_scope.unordered.unlimited
-        end
-
-        def import_scope(scope, batch_size)
-          scope = scope.unordered.order(::Sequel.asc(primary_key)).limit(batch_size)
-
-          ids = pluck_ids(scope)
-          result = true
-
-          while ids.present?
-            result &= yield grouped_objects(default_scope_where_ids_in(ids).all)
-            break if ids.size < batch_size
-            ids = pluck_ids(scope.where { |o| o.__send__(primary_key) > ids.last })
-          end
-
-          result
-        end
-
-        def primary_key
-          target.primary_key
-        end
-
-        def all_scope
-          target.dataset
-        end
-
-        def pluck_ids(scope)
-          scope.distinct.select_map(primary_key)
-        end
-
-        def scope_where_ids_in(scope, ids)
-          scope.where(primary_key => Array.wrap(ids))
-        end
-
-        def model_of_relation relation
-          relation.model
-        end
-
-        def relation_class
-          ::Sequel::Dataset
-        end
-
-        def object_class
-          ::Sequel::Model
-        end
-
-        def load_scope_objects(*args)
-          super.all
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type/crutch.rb

@@ -1,31 +0,0 @@
-module Chewy
-  class Type
-    module Crutch
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :_crutches
-        self._crutches = {}
-      end
-
-      class Crutches
-        def initialize type, collection
-          @type, @collection = type, collection
-          @type._crutches.keys.each do |name|
-            singleton_class.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-              def #{name}
-                @#{name} ||= @type._crutches[:#{name}].call @collection
-              end
-            METHOD
-          end
-        end
-      end
-
-      module ClassMethods
-        def crutch name, &block
-          self._crutches = _crutches.merge(name.to_sym => block)
-        end
-      end
-    end
-  end
-end