chewy 6.0.0 → 7.6.0

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,67 +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!
-          Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified') if Chewy.logger && @default_scope.options.values_at(:sort, :limit, :skip).compact.present?
-
-          @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,93 +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!
-          Chewy.logger.warn('Default type scope order, limit and offset are ignored and will be nullified') if Chewy.logger && @default_scope != @default_scope.unordered.unlimited
-
-          @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)
-          ::Sequel.qualify(target.table_name, column)
-        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(full_column_name(primary_key).asc).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| 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.each_key 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.root
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type/observe.rb

@@ -1,82 +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
-            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
-
-            type = Chewy.derive_type(reference)
-
-            next if Chewy.strategy.current.name == :bypass
-
-            backreference = if method && method.to_s == 'self'
-              self
-            elsif method
-              send(method)
-            else
-              instance_eval(&block)
-            end
-
-            type.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,120 +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 consistency direct_import journal
-      pipeline raw_import refresh replication
-    ].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 was 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

data/lib/sequel/plugins/chewy_observe.rb

@@ -1,63 +0,0 @@
-require 'active_support/callbacks'
-
-module Sequel
-  module Plugins
-    # This Sequel plugin adds support for chewy's model-observing hook for
-    # updating indexes after model save or destroy.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses support the `update_index` hook (called
-    #   # before loading subclasses).
-    #   Sequel::Model.plugin :chewy_observe
-    #
-    #   # Make the Album class support the `update_index` hooks.
-    #   Album.plugin :chewy_observe
-    #
-    #   # Declare one or more `update_index` observers in model.
-    #   class Album < Sequel::Model
-    #     update_index('albums#album') { self }
-    #   end
-    #
-    module ChewyObserve
-      extend ::Chewy::Type::Observe::Helpers
-
-      def self.apply(model)
-        model.instance_eval do
-          include ActiveSupport::Callbacks
-          define_callbacks :commit, :destroy_commit, :save, :destroy
-        end
-      end
-
-      # Class level methods for Sequel::Model
-      #
-      module ClassMethods
-        def update_index(type_name, *args, &block)
-          callback_options = ChewyObserve.extract_callback_options!(args)
-          update_proc = ChewyObserve.update_proc(type_name, *args, &block)
-
-          set_callback(:save, callback_options, &update_proc)
-          set_callback(:destroy, callback_options, &update_proc)
-        end
-      end
-
-      # Instance level methods for Sequel::Model
-      #
-      module InstanceMethods
-        def after_save
-          run_callbacks(:save) do
-            super
-            db.after_commit {} if Chewy.use_after_commit_callbacks
-          end
-        end
-
-        def after_destroy
-          run_callbacks(:destroy) do
-            super
-            db.after_commit {} if Chewy.use_after_commit_callbacks
-          end
-        end
-      end
-    end
-  end
-end

data/spec/chewy/search/pagination/will_paginate_examples.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-shared_examples :will_paginate do |request_base_class|
-  before { Chewy.massacre }
-
-  before do
-    stub_index(:products) do
-      define_type(:product) do
-        field :name
-        field :age, type: 'integer'
-      end
-    end
-  end
-
-  let(:except_fields) { %w[_score _explanation] }
-  let(:request_class) do
-    Class.new(request_base_class).tap do |k|
-      k.include Chewy::Search::Pagination::WillPaginate
-    end
-  end
-  let(:search) { request_class.new(ProductsIndex).order(:age) }
-
-  specify { expect(search.total_pages).to eq(1) } # defaults to 1 on will_paginate
-
-  context do
-    let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
-
-    before { ProductsIndex::Product.import!(data.map { |h| double(h) }) }
-    before { allow(::WillPaginate).to receive_messages(per_page: 3) }
-
-    describe '#page' do
-      specify { expect(search.map { |e| e.attributes.except(*except_fields) }).to match_array(data) }
-      specify { expect(search.page(1).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..2]) }
-      specify { expect(search.page(2).map { |e| e.attributes.except(*except_fields) }).to eq(data[3..5]) }
-    end
-
-    describe '#paginate' do
-      specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..7]) }
-      specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except(*except_fields) }).to eq(data[4..5]) }
-      specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..4]) }
-      specify { expect(search.paginate(per_page: 4).map { |e| e.attributes.except(*except_fields) }).to eq(data[0..3]) }
-    end
-
-    describe '#total_pages' do
-      specify { expect(search.paginate(page: 2, per_page: 5).total_pages).to eq(2) }
-      specify { expect(search.paginate(page: 3, per_page: 2).total_pages).to eq(5) }
-    end
-
-    describe '#total_entries' do
-      specify { expect(search.paginate(page: 1, per_page: 4).total_entries).to eq(10) }
-      specify { expect(search.query(range: {age: {gt: 20}}).limit(3).total_entries).to eq(8) }
-    end
-
-    describe '#load' do
-      specify { expect(search.paginate(per_page: 2, page: 1).load.first.age).to eq(10) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.first.age).to eq(50) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.page(2).load.first.age).to eq(30) }
-
-      specify { expect(search.paginate(per_page: 4, page: 1).load.total_count).to eq(10) }
-      specify { expect(search.paginate(per_page: 2, page: 3).load.total_pages).to eq(5) }
-    end
-  end
-end