chewy 0.9.0 → 0.10.0

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

@@ -1,27 +0,0 @@
-module Chewy
-  class Query
-    module Pagination
-      module WillPaginate
-        extend ActiveSupport::Concern
-        include ::WillPaginate::CollectionMethods
-
-        attr_reader :current_page, :per_page
-
-        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
-      end
-    end
-  end
-end
-
-Chewy::Query.send :include, Chewy::Query::Pagination::WillPaginate

data/lib/chewy/query/scoping.rb

@@ -1,20 +0,0 @@
-module Chewy
-  class Query
-    module Scoping
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        def scopes
-          Thread.current[:chewy_scopes] ||= []
-        end
-      end
-
-      def scoping
-        self.class.scopes.push(self)
-        yield
-      ensure
-        self.class.scopes.pop
-      end
-    end
-  end
-end

data/spec/chewy/journal/apply_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Journal::Apply do
-  describe '.since' do
-    context 'with an index filter' do
-      let(:time) { Time.now }
-
-      before do
-        stub_model(:city) do
-          update_index 'city', :self
-        end
-        stub_model(:country) do
-          update_index 'country', :self
-        end
-
-        stub_index('city') do
-          define_type City do
-            default_import_options journal: true
-          end
-        end
-        stub_index('country') do
-          define_type Country do
-            default_import_options journal: true
-          end
-        end
-
-        Chewy.massacre
-        Timecop.freeze(time)
-      end
-
-      specify do
-        Chewy.strategy(:urgent) do
-          Array.new(2) { |i| City.create!(id: i + 1) }
-          Array.new(2) { |i| Country.create!(id: i + 1) }
-
-          # simulate lost data
-          Chewy.client.delete(index: 'city', type: 'city', id: 1, refresh: true)
-          Chewy.client.delete(index: 'country', type: 'country', id: 1, refresh: true)
-          expect(CityIndex.all.to_a.length).to eq 1
-          expect(CountryIndex.all.to_a.length).to eq 1
-
-          # Replay on specific index
-          described_class.since(time, only: [CityIndex])
-          expect(CityIndex.all.to_a.length).to eq 2
-          expect(CountryIndex.all.to_a.length).to eq 1
-
-          # Replay on both
-          Chewy.client.delete(index: 'city', type: 'city', id: 1, refresh: true)
-          expect(CityIndex.all.to_a.length).to eq 1
-          described_class.since(time, only: [CityIndex, CountryIndex])
-          expect(CityIndex.all.to_a.length).to eq 2
-          expect(CountryIndex.all.to_a.length).to eq 2
-        end
-      end
-    end
-
-    context 'retries' do
-      let(:time) { Time.now.to_i }
-      before do
-        stub_model(:city) do
-          update_index 'city', :self
-        end
-        stub_index('city') do
-          define_type City do
-            default_import_options journal: true
-          end
-        end
-        Chewy.massacre
-        Timecop.freeze
-        Chewy.strategy(:urgent)
-        City.create!(id: 1)
-      end
-
-      after do
-        Chewy.strategy.pop
-      end
-
-      specify 'journal was cleaned after the first call' do
-        expect(Chewy::Journal::Entry)
-          .to receive(:since).exactly(2).and_call_original
-        Chewy::Journal::Apply.since(time)
-      end
-
-      context 'endless journal' do
-        let(:count_of_checks) { 10 } # default
-        let!(:journal_records) do
-          record = Chewy::Journal::Entry.since(time).first
-          Array.new(count_of_checks) do |i|
-            r = record.dup
-            r.created_at = time.to_i + i
-            r.object_ids = [i]
-            r
-          end
-        end
-
-        specify '10 retries by default' do
-          expect(Chewy::Journal::Entry)
-            .to receive(:since).exactly(count_of_checks) { [journal_records.shift].compact }
-          Chewy::Journal::Apply.since(time)
-        end
-
-        specify 'with :once parameter set' do
-          expect(Chewy::Journal::Entry)
-            .to receive(:since).exactly(1) { [journal_records.shift].compact }
-          Chewy::Journal::Apply.since(time, once: true)
-        end
-
-        context 'with retries parameter set' do
-          let(:retries) { 5 }
-
-          specify do
-            expect(Chewy::Journal::Entry)
-              .to receive(:since).exactly(retries) { [journal_records.shift].compact }
-            Chewy::Journal::Apply.since(time, retries: retries)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/chewy/journal/entry_spec.rb

@@ -1,237 +0,0 @@
-require 'spec_helper'
-
-describe Chewy::Journal::Entry do
-  before do
-    stub_model(:city) do
-      update_index 'city', :self
-    end
-    stub_index('city') do
-      define_type City do
-        default_import_options journal: true
-      end
-    end
-  end
-
-  describe '.since' do
-    let(:time) { Time.now.to_i }
-    before do
-      Timecop.freeze(time)
-      Chewy.massacre
-      Chewy.strategy(:urgent) { City.create!(id: 1) }
-    end
-    subject { described_class.since(time) }
-
-    its(:length) { is_expected.to eq(1) }
-
-    context 'with indices parameter provided' do
-      subject { described_class.since(time, indices) }
-
-      context 'it ignores empty array' do
-        let(:indices) { [] }
-        its(:length) { is_expected.to eq(1) }
-      end
-
-      context do
-        let(:indices) { [CityIndex::City2] }
-        before do
-          stub_index('city') do
-            define_type :city2 do
-              default_import_options journal: true
-            end
-          end
-        end
-
-        its(:length) { is_expected.to eq(1) }
-      end
-    end
-  end
-
-  describe '.group' do
-    let(:full_type_name) { 'type' }
-    let(:another_full_type_name) { 'type' }
-    let(:entry) { described_class.new('object_ids' => [1]) }
-    let(:another_entry) { described_class.new('object_ids' => [2]) }
-    before do
-      allow(entry)
-        .to receive(:full_type_name).and_return(full_type_name)
-      allow(another_entry)
-        .to receive(:full_type_name).and_return(another_full_type_name)
-    end
-    subject { described_class.group([entry, another_entry]) }
-
-    specify do
-      expect(subject.length).to eq(1)
-      expect(subject.first.object_ids).to eq([1, 2])
-    end
-
-    context do
-      let(:another_full_type_name) { 'whatever' }
-
-      specify do
-        expect(subject.length).to eq(2)
-        expect(subject.first.object_ids).to eq(entry.object_ids)
-        expect(subject.last.object_ids).to eq(another_entry.object_ids)
-      end
-    end
-  end
-
-  describe '.recent_timestamp' do
-    let(:time) { Time.now.to_i }
-    let(:entry) { described_class.new('created_at' => time) }
-    let(:another_entry) { described_class.new('created_at' => time + 1) }
-    subject { described_class.recent_timestamp([entry, another_entry]) }
-
-    it { is_expected.to eq(time + 1) }
-  end
-
-  describe '.subtract' do
-    let(:full_type_name) { 'type' }
-    let(:another_full_type_name) { 'type' }
-    let(:entry) { described_class.new('object_ids' => [1]) }
-    let(:another_entry) { described_class.new('object_ids' => [2]) }
-    before do
-      allow(entry)
-        .to receive(:full_type_name).and_return(full_type_name)
-      allow(another_entry)
-        .to receive(:full_type_name).and_return(another_full_type_name)
-    end
-    let(:from) { [entry] }
-    let(:what) { [another_entry] }
-    subject { described_class.subtract(from, what) }
-
-    specify { expect { subject }.not_to change { from.length } }
-    specify { expect(entry.object_ids).to eq([1]) }
-
-    context 'object_ids have same elements' do
-      let(:another_entry) { described_class.new('object_ids' => [1, 2]) }
-
-      specify { expect { subject }.to change { from.length }.from(1).to(0) }
-      specify do
-        subject
-        expect(entry.object_ids).to eq([])
-      end
-
-      context 'not all elements are covered by subtracting array' do
-        let(:entry) { described_class.new('object_ids' => [1, 3]) }
-
-        specify { expect { subject }.not_to change { from.length } }
-        specify do
-          subject
-          expect(entry.object_ids).to eq([3])
-        end
-      end
-    end
-  end
-
-  describe '#merge' do
-    let(:time) { Time.now.to_i }
-    let(:index_name) { 'index' }
-    let(:type_name) { 'type' }
-    let(:object_ids) { [1] }
-    let(:entry) do
-      described_class.new('index_name' => index_name,
-                          'type_name' => type_name,
-                          'object_ids' => object_ids,
-                          'created_at' => time)
-    end
-    let(:another_index_name) { 'index' }
-    let(:another_type_name) { 'type' }
-    let(:another_object_ids) { [2] }
-    let(:another_time) { time + 1 }
-    let(:another_entry) do
-      described_class.new('index_name' => another_index_name,
-                          'type_name' => another_type_name,
-                          'object_ids' => another_object_ids,
-                          'created_at' => another_time)
-    end
-    subject { entry.merge(another_entry) }
-
-    specify do
-      expect(subject).to eq(entry)
-      expect(entry.created_at).to eq(another_entry.created_at)
-      expect(entry.object_ids).to eq([1, 2])
-    end
-
-    shared_examples_for 'merge does not change the entry' do
-      it { is_expected.to eq(entry) }
-      specify { expect { subject }.not_to change(entry, :created_at) }
-      specify { expect { subject }.not_to change(entry, :object_ids) }
-    end
-
-    context 'different types' do
-      let(:another_type_name) { 'whatever' }
-      include_examples 'merge does not change the entry'
-    end
-
-    context 'merge with nil' do
-      let(:another_entry) { nil }
-      include_examples 'merge does not change the entry'
-    end
-
-    context 'original entry has more recent time' do
-      let(:another_time) { time - 1 }
-      specify { expect { subject }.not_to change(entry, :created_at) }
-    end
-  end
-
-  describe '#empty?' do
-    let(:object_ids) { [] }
-    subject { described_class.new('object_ids' => object_ids).empty? }
-
-    it { is_expected.to eq(true) }
-
-    context do
-      let(:object_ids) { nil }
-      it { is_expected.to eq(true) }
-    end
-
-    context do
-      let(:object_ids) { [1] }
-      it { is_expected.to eq(false) }
-    end
-  end
-
-  describe '#full_type_name' do
-    subject do
-      described_class.new('index_name' => 'index', 'type_name' => 'type')
-        .full_type_name
-    end
-    it { is_expected.to eq('index#type') }
-  end
-
-  describe '#index' do
-    let(:index_name) { 'wrong_index_name' }
-    let(:type_name) { 'city' }
-    subject do
-      described_class
-        .new('index_name' => index_name, 'type_name' => type_name).index
-    end
-
-    specify { expect { subject }.to raise_error(Chewy::UnderivableType) }
-
-    context do
-      let(:index_name) { 'city' }
-      it { is_expected.to eq(CityIndex::City) }
-    end
-  end
-
-  describe '#==' do
-    let(:full_type_name) { 'type' }
-    let(:another_full_type_name) { 'type' }
-    let(:entry) { described_class.new }
-    let(:another_entry) { described_class.new }
-    before do
-      expect(entry).to receive(:full_type_name).and_return(full_type_name)
-      expect(another_entry)
-        .to receive(:full_type_name).and_return(another_full_type_name)
-    end
-    subject { entry == another_entry }
-
-    it { is_expected.to eq(true) }
-
-    context do
-      let(:another_full_type_name) { 'whatever' }
-      it { is_expected.to eq(false) }
-    end
-  end
-end

data/spec/chewy/query/pagination/will_paginage_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-if defined?(::WillPaginate)
-  describe Chewy::Query::Pagination::WillPaginate do
-    before { Chewy.massacre }
-
-    before do
-      stub_index(:products) do
-        define_type(:product) do
-          field :name
-          field :age, type: 'integer'
-        end
-      end
-    end
-
-    let(:search) { 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('_score', '_explanation') }).to match_array(data) }
-        specify { expect(search.page(1).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..2]) }
-        specify { expect(search.page(2).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[3..5]) }
-      end
-
-      describe '#paginate' do
-        specify { expect(search.paginate(page: 2, per_page: 4).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..7]) }
-        specify { expect(search.paginate(per_page: 2, page: 3).page(3).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[4..5]) }
-        specify { expect(search.paginate(per_page: 5).map { |e| e.attributes.except('_score', '_explanation') }).to eq(data[0..4]) }
-        specify { expect(search.paginate(per_page: 4).map { |e| e.attributes.except('_score', '_explanation') }).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.filter(numeric_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
-end