chewy 7.1.0 → 7.2.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/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

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

@@ -1,23 +0,0 @@
-require 'chewy/search/pagination/will_paginate_examples'
-
-describe Chewy::Search::Pagination::WillPaginate do
-  it_behaves_like :will_paginate, Chewy::Search::Request do
-    describe '#objects' do
-      let(:data) { Array.new(12) { |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: 17) }
-
-      # specify { expect(search.current_page).to eq(1) }
-      # specify { expect(search.per_page).to eq(0) }
-      specify { expect(search.objects.class).to eq(WillPaginate::Collection) }
-      specify { expect(search.objects.total_entries).to eq(12) }
-      specify { expect(search.objects.per_page).to eq(17) }
-      specify { expect(search.objects.current_page).to eq(1) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.class).to eq(WillPaginate::Collection) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.total_entries).to eq(12) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.per_page).to eq(2) }
-      specify { expect(search.paginate(per_page: 2, page: 3).objects.current_page).to eq(3) }
-    end
-  end
-end

data/spec/chewy/strategy/resque_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-if defined?(::Resque)
-  require 'resque_spec'
-
-  describe Chewy::Strategy::Resque, :orm do
-    around { |example| Chewy.strategy(:bypass) { example.run } }
-    before { ResqueSpec.reset! }
-    before do
-      stub_model(:city) do
-        update_index('cities#city') { self }
-      end
-
-      stub_index(:cities) do
-        define_type City
-      end
-    end
-
-    let(:city) { City.create!(name: 'hello') }
-    let(:other_city) { City.create!(name: 'world') }
-
-    specify do
-      expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :resque)
-    end
-
-    specify do
-      with_resque do
-        expect { [city, other_city].map(&:save!) }
-          .to update_index(CitiesIndex::City, strategy: :resque)
-          .and_reindex(city, other_city).only
-      end
-    end
-
-    specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::Resque::Worker.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
-    end
-
-    specify do
-      allow(Chewy).to receive(:disable_refresh_async).and_return(true)
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::Resque::Worker.perform('CitiesIndex::City', [city.id, other_city.id], suffix: '201601')
-    end
-  end
-end

data/spec/chewy/strategy/shoryuken_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-if defined?(::Shoryuken)
-  require 'aws-sdk-sqs'
-
-  describe Chewy::Strategy::Shoryuken do
-    around do |example|
-      shoryuken_settings = Chewy.settings[:shoryuken]
-      Chewy.settings[:shoryuken] = {queue: 'low'}
-      Chewy.strategy(:bypass) { example.run }
-      Chewy.settings[:shoryuken] = shoryuken_settings
-    end
-    before { ::Shoryuken.groups.clear }
-    before do
-      stub_model(:city) do
-        update_index('cities#city') { self }
-      end
-
-      stub_index(:cities) do
-        define_type City
-      end
-    end
-
-    let(:city) { City.create!(name: 'hello') }
-    let(:other_city) { City.create!(name: 'world') }
-    let(:queue) { instance_double(::Shoryuken::Queue) }
-
-    before do
-      allow(::Shoryuken::Queue).to receive(:new).and_return(queue)
-      allow(queue).to receive(:send_message).and_return(nil)
-    end
-
-    specify do
-      expect { [city, other_city].map(&:save!) }
-        .not_to update_index(CitiesIndex::City, strategy: :shoryuken)
-    end
-
-    specify do
-      expect(Chewy::Strategy::Shoryuken::Worker).to receive(:perform_async)
-        .with(hash_including(type: 'CitiesIndex::City', ids: [city.id, other_city.id]), hash_including(queue: 'low'))
-      Chewy.strategy(:shoryuken) do
-        [city, other_city].map(&:save!)
-      end
-    end
-
-    let(:body) do
-      {
-        'type' => 'CitiesIndex::City',
-        'ids' => [city.id, other_city.id],
-        'options' => {'suffix' => '201601'}
-      }
-    end
-    let(:sqs_msg) do
-      double id: 'fc754df7-9cc2-4c41-96ca-5996a44b771e',
-             body: body,
-             delete: nil
-    end
-
-    specify do
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601')
-      Chewy::Strategy::Shoryuken::Worker.new.perform(sqs_msg, body)
-    end
-
-    specify do
-      allow(Chewy).to receive(:disable_refresh_async).and_return(true)
-      expect(CitiesIndex::City).to receive(:import!).with([city.id, other_city.id], suffix: '201601', refresh: false)
-      Chewy::Strategy::Shoryuken::Worker.new.perform(sqs_msg, body)
-    end
-  end
-end