chewy 0.10.1 → 7.3.2

data/lib/chewy/search/pagination/will_paginate.rb

@@ -1,43 +0,0 @@
-module Chewy
-  module Search
-    module Pagination
-      # This module provides `WillPaginate` support for {Chewy::Search::Request}
-      # It is included automatically if `WillPaginate` is available.
-      #
-      # @example
-      #   PlacesIndex.all.paginate(page: 3, per_page: 10).order(:name)
-      #   # => <PlacesIndex::Query {..., :body=>{:size=>10, :from=>20, :sort=>["name"]}}>
-      module WillPaginate
-        extend ActiveSupport::Concern
-
-        included do
-          include ::WillPaginate::CollectionMethods
-          attr_reader :current_page, :per_page
-        end
-
-        def paginate(options = {})
-          @current_page = ::WillPaginate::PageNumber(options[:page] || @current_page || 1)
-          @page_multiplier = @current_page - 1
-          @per_page = (options[:per_page] || @per_page || ::WillPaginate.per_page).to_i
-
-          # call Chewy::Query methods to limit results
-          limit(@per_page).offset(@page_multiplier * @per_page)
-        end
-
-        def page(page)
-          paginate(page: page)
-        end
-
-      private
-
-        def paginated_collection(collection)
-          page = current_page || 1
-          per = per_page || ::WillPaginate.per_page
-          ::WillPaginate::Collection.create(page, per, total_entries) do |pager|
-            pager.replace collection
-          end
-        end
-      end
-    end
-  end
-end

data/lib/chewy/search/parameters/types.rb

@@ -1,20 +0,0 @@
-require 'chewy/search/parameters/storage'
-
-module Chewy
-  module Search
-    class Parameters
-      # A standard string array storage with one exception: rendering is empty.
-      #
-      # @see Chewy::Search::Parameters::StringArrayStorage
-      class Types < Storage
-        include StringArrayStorage
-
-        # Doesn't render anything, has specialized rendering logic in
-        # {Chewy::Search::Request}
-        #
-        # @return [nil]
-        def render; end
-      end
-    end
-  end
-end

data/lib/chewy/strategy/resque.rb

@@ -1,27 +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 = {})
-          options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async
-          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/strategy/shoryuken.rb

@@ -1,40 +0,0 @@
-module Chewy
-  class Strategy
-    # The strategy works the same way as atomic, but performs
-    # async index update driven by shoryuken
-    #
-    #   Chewy.strategy(:shoryuken) 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 Shoryuken < Atomic
-      class Worker
-        include ::Shoryuken::Worker
-
-        shoryuken_options auto_delete: true,
-                          body_parser: :json
-
-        def perform(_sqs_msg, body)
-          options = body['options'] || {}
-          options[:refresh] = !Chewy.disable_refresh_async if Chewy.disable_refresh_async
-          body['type'].constantize.import!(body['ids'], options.deep_symbolize_keys!)
-        end
-      end
-
-      def leave
-        @stash.each do |type, ids|
-          next if ids.empty?
-          Shoryuken::Worker.perform_async({type: type.name, ids: ids}, queue: shoryuken_queue)
-        end
-      end
-
-    private
-
-      def shoryuken_queue
-        Chewy.settings.fetch(:shoryuken, {})[:queue] || 'chewy'
-      end
-    end
-  end
-end

data/lib/chewy/type/actions.rb

@@ -1,43 +0,0 @@
-module Chewy
-  class Type
-    module Actions
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        # Deletes all documents of a type and reimports them
-        #
-        # @example
-        #   UsersIndex::User.reset
-        #
-        # @see Chewy::Type::Import::ClassMethods#import
-        # @see Chewy::Type::Import::ClassMethods#import
-        # @return [true, false] the result of import
-        def reset
-          delete_all
-          import
-        end
-
-        # Performs missing and outdated objects synchronization for the current type.
-        #
-        # @example
-        #   UsersIndex::User.sync
-        #
-        # @see Chewy::Type::Syncer
-        # @param parallel [true, Integer, Hash] options for parallel execution or the number of processes
-        # @return [Hash{Symbol, Object}, nil] a number of missing and outdated documents reindexed and their ids, nil in case of errors
-        def sync(parallel: nil)
-          syncer = Syncer.new(self, parallel: parallel)
-          count = syncer.perform
-          {count: count, missing: syncer.missing_ids, outdated: syncer.outdated_ids} if count
-        end
-
-        # A {Chewy::Journal} instance for the particular type
-        #
-        # @return [Chewy::Journal] journal instance
-        def journal
-          @journal ||= Chewy::Journal.new(self)
-        end
-      end
-    end
-  end
-end

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

@@ -1,69 +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, options)
-          pluck_in_batches(scope, options.slice(:batch_size)).map do |ids|
-            yield grouped_objects(default_scope_where_ids_in(ids))
-          end.all?
-        end
-
-        def primary_key
-          :_id
-        end
-
-        def pluck(scope, fields: [])
-          scope.pluck(primary_key, *fields)
-        end
-
-        def pluck_in_batches(scope, fields: [], batch_size: nil, **options)
-          return enum_for(:pluck_in_batches, scope, fields: fields, batch_size: batch_size, **options) unless block_given?
-
-          scope.batch_size(batch_size).no_timeout.pluck(primary_key, *fields).each_slice(batch_size) do |batch|
-            yield batch
-          end
-        end
-
-        def scope_where_ids_in(scope, ids)
-          scope.where(primary_key.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/sequel.rb

@@ -1,95 +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, options)
-          pluck_in_batches(scope, options.slice(:batch_size)).inject(true) do |result, ids|
-            result & yield(grouped_objects(default_scope_where_ids_in(ids).all))
-          end
-        end
-
-        def primary_key
-          target.primary_key
-        end
-
-        def full_column_name(column)
-          "#{target.table_name}__#{column}".to_sym
-        end
-
-        def all_scope
-          target.dataset
-        end
-
-        def target_columns
-          @target_columns ||= target.columns.to_set
-        end
-
-        def pluck(scope, fields: [])
-          fields = fields.map(&:to_sym).unshift(primary_key).map do |column|
-            target_columns.include?(column) ? full_column_name(column) : column
-          end
-          scope.distinct.select_map(fields.one? ? fields.first : fields)
-        end
-
-        def pluck_in_batches(scope, fields: [], batch_size: nil, **options)
-          return enum_for(:pluck_in_batches, scope, fields: fields, batch_size: batch_size, **options) unless block_given?
-
-          scope = scope.unordered.order(::Sequel.asc(full_column_name(primary_key))).limit(batch_size)
-
-          ids = pluck(scope, fields: fields)
-          count = 0
-
-          while ids.present?
-            yield ids
-            break if ids.size < batch_size
-            last_id = ids.last.is_a?(Array) ? ids.last.first : ids.last
-            ids = pluck(scope.where { |o| o.__send__(full_column_name(primary_key)) > last_id }, fields: fields)
-          end
-
-          count
-        end
-
-        def scope_where_ids_in(scope, ids)
-          scope.where(full_column_name(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,32 +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 = type
-          @collection = 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

data/lib/chewy/type/import/bulk_builder.rb

@@ -1,122 +0,0 @@
-module Chewy
-  class Type
-    module Import
-      # This class purpose is to build ES client-acceptable bulk
-      # request body from the passed objects for index and deletion.
-      # It handles parent-child relationships as well by fetching
-      # existing documents from ES, taking their `_parent` field and
-      # using it in the bulk body.
-      # If fields are passed - it creates partial update entries except for
-      # the cases when the type has parent and parent_id has been changed.
-      class BulkBuilder
-        # @param type [Chewy::Type] desired type
-        # @param index [Array<Object>] objects to index
-        # @param delete [Array<Object>] objects or ids to delete
-        # @param fields [Array<Symbol, String>] and array of fields for documents update
-        def initialize(type, index: [], delete: [], fields: [])
-          @type = type
-          @index = index
-          @delete = delete
-          @fields = fields.map!(&:to_sym)
-        end
-
-        # Returns ES API-ready bulk requiest body.
-        # @see https://github.com/elastic/elasticsearch-ruby/blob/master/elasticsearch-api/lib/elasticsearch/api/actions/bulk.rb
-        # @return [Array<Hash>] bulk body
-        def bulk_body
-          @bulk_body ||= @index.flat_map(&method(:index_entry)).concat(
-            @delete.flat_map(&method(:delete_entry))
-          )
-        end
-
-        # The only purpose of this method is to cache document ids for
-        # all the passed object for index to avoid ids recalculation.
-        #
-        # @return [Hash[String => Object]] an ids-objects index hash
-        def index_objects_by_id
-          @index_objects_by_id ||= index_object_ids.invert.stringify_keys!
-        end
-
-      private
-
-        def crutches
-          @crutches ||= Chewy::Type::Crutch::Crutches.new @type, @index
-        end
-
-        def parents
-          return unless type_root.parent_id
-
-          @parents ||= begin
-            ids = @index.map do |object|
-              object.respond_to?(:id) ? object.id : object
-            end
-            ids.concat(@delete.map do |object|
-              object.respond_to?(:id) ? object.id : object
-            end)
-            @type.filter(ids: {values: ids}).order('_doc').pluck(:_id, :_parent).to_h
-          end
-        end
-
-        def index_entry(object)
-          entry = {}
-          entry[:_id] = index_object_ids[object] if index_object_ids[object]
-
-          if parents
-            entry[:parent] = type_root.compose_parent(object)
-            parent = entry[:_id].present? && parents[entry[:_id].to_s]
-          end
-
-          if parent && entry[:parent].to_s != parent
-            entry[:data] = @type.compose(object, crutches)
-            [{delete: entry.except(:data).merge(parent: parent)}, {index: entry}]
-          elsif @fields.present?
-            return [] unless entry[:_id]
-            entry[:data] = {doc: @type.compose(object, crutches, fields: @fields)}
-            [{update: entry}]
-          else
-            entry[:data] = @type.compose(object, crutches)
-            [{index: entry}]
-          end
-        end
-
-        def delete_entry(object)
-          entry = {}
-          entry[:_id] = entry_id(object)
-          entry[:_id] ||= object.as_json
-
-          return [] if entry[:_id].blank?
-
-          if parents
-            parent = entry[:_id].present? && parents[entry[:_id].to_s]
-            return [] unless parent
-            entry[:parent] = parent
-          end
-
-          [{delete: entry}]
-        end
-
-        def entry_id(object)
-          if type_root.id
-            type_root.compose_id(object)
-          else
-            id = object.id if object.respond_to?(:id)
-            id ||= object[:id] || object['id'] if object.is_a?(Hash)
-            id = id.to_s if defined?(BSON) && id.is_a?(BSON::ObjectId)
-            id
-          end
-        end
-
-        def index_object_ids
-          @index_object_ids ||= @index.each_with_object({}) do |object, result|
-            id = entry_id(object)
-            result[object] = id if id.present?
-          end
-        end
-
-        def type_root
-          @type_root = @type.send(:build_root)
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type/observe.rb

@@ -1,78 +0,0 @@
-module Chewy
-  class Type
-    module Observe
-      extend ActiveSupport::Concern
-
-      module Helpers
-        def update_proc(type_name, *args, &block)
-          options = args.extract_options!
-          method = args.first
-
-          proc do
-            backreference = if method && method.to_s == 'self'
-              self
-            elsif method
-              send(method)
-            else
-              instance_eval(&block)
-            end
-
-            reference = if type_name.is_a?(Proc)
-              if type_name.arity.zero?
-                instance_exec(&type_name)
-              else
-                type_name.call(self)
-              end
-            else
-              type_name
-            end
-
-            Chewy.derive_type(reference).update_index(backreference, options)
-          end
-        end
-
-        def extract_callback_options!(args)
-          options = args.extract_options!
-          result = options.each_key.with_object({}) do |key, hash|
-            hash[key] = options.delete(key) if %i[if unless].include?(key)
-          end
-          args.push(options) unless options.empty?
-          result
-        end
-      end
-
-      extend Helpers
-
-      module MongoidMethods
-        def update_index(type_name, *args, &block)
-          callback_options = Observe.extract_callback_options!(args)
-          update_proc = Observe.update_proc(type_name, *args, &block)
-
-          after_save(callback_options, &update_proc)
-          after_destroy(callback_options, &update_proc)
-        end
-      end
-
-      module ActiveRecordMethods
-        def update_index(type_name, *args, &block)
-          callback_options = Observe.extract_callback_options!(args)
-          update_proc = Observe.update_proc(type_name, *args, &block)
-
-          if Chewy.use_after_commit_callbacks
-            after_commit(callback_options, &update_proc)
-          else
-            after_save(callback_options, &update_proc)
-            after_destroy(callback_options, &update_proc)
-          end
-        end
-      end
-
-      module ClassMethods
-        def update_index(objects, options = {})
-          Chewy.strategy.current.update(self, objects, options)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type.rb

@@ -1,117 +0,0 @@
-require 'chewy/search'
-require 'chewy/type/adapter/object'
-require 'chewy/type/adapter/active_record'
-require 'chewy/type/adapter/mongoid'
-require 'chewy/type/adapter/sequel'
-require 'chewy/type/mapping'
-require 'chewy/type/wrapper'
-require 'chewy/type/observe'
-require 'chewy/type/actions'
-require 'chewy/type/syncer'
-require 'chewy/type/crutch'
-require 'chewy/type/import'
-require 'chewy/type/witchcraft'
-
-module Chewy
-  class Type
-    IMPORT_OPTIONS_KEYS = %i[batch_size bulk_size refresh consistency replication raw_import journal].freeze
-
-    include Search
-    include Mapping
-    include Wrapper
-    include Observe
-    include Actions
-    include Crutch
-    include Witchcraft
-    include Import
-
-    singleton_class.delegate :index_name, :derivable_index_name, :client, to: :index
-
-    class_attribute :_default_import_options
-    self._default_import_options = {}
-
-    class << self
-      # Chewy index current type belongs to. Defined inside `Chewy.create_type`
-      #
-      def index
-        raise NotImplementedError, 'Looks like this type ws defined outside the index scope and `.index` method is undefined for it'
-      end
-
-      # Current type adapter. Defined inside `Chewy.create_type`, derived from
-      # `Chewy::Index.define_type` arguments.
-      #
-      def adapter
-        raise NotImplementedError
-      end
-
-      # Returns type name string
-      #
-      def type_name
-        adapter.type_name
-      end
-
-      # Appends type name to {Chewy::Index.derivable_name}
-      #
-      # @example
-      #   class Namespace::UsersIndex < Chewy::Index
-      #     define_type User
-      #   end
-      #   UsersIndex::User.derivable_name # => 'namespace/users#user'
-      #
-      # @see Chewy::Index.derivable_name
-      # @return [String, nil] derivable name or nil when it is impossible to calculate
-      def derivable_name
-        @derivable_name ||= [index.derivable_name, type_name].join('#') if index && index.derivable_name
-      end
-
-      # This method is an API shared with {Chewy::Index}, added for convenience.
-      #
-      # @return [Chewy::Type] array containing itself
-      def types
-        [self]
-      end
-
-      # Returns list of public class methods defined in current type
-      #
-      def scopes
-        public_methods - Chewy::Type.public_methods
-      end
-
-      def default_import_options(params)
-        params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
-        self._default_import_options = _default_import_options.merge(params)
-      end
-
-      def method_missing(method, *args, &block)
-        if index.scopes.include?(method)
-          define_singleton_method method do |*method_args, &method_block|
-            all.scoping { index.public_send(method, *method_args, &method_block) }
-          end
-          send(method, *args, &block)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method, _)
-        index.scopes.include?(method) || super
-      end
-
-      def const_missing(name)
-        to_resolve = "#{self}::#{name}"
-        to_resolve[index.to_s] = ''
-
-        @__resolved_constants ||= {}
-
-        if to_resolve.empty? || @__resolved_constants[to_resolve]
-          super
-        else
-          @__resolved_constants[to_resolve] = true
-          to_resolve.constantize
-        end
-      rescue NotImplementedError
-        super
-      end
-    end
-  end
-end