chewy 0.7.0 → 0.8.0

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

@@ -24,7 +24,7 @@ module Chewy
         end
 
         def identify collection
-          ids = if collection.is_a?(relation_class)
+          if collection.is_a?(relation_class)
             pluck_ids(collection)
           else
             Array.wrap(collection).map do |entity|

data/lib/chewy/type/crutch.rb

@@ -0,0 +1,31 @@
+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

data/lib/chewy/type/import.rb

@@ -78,11 +78,12 @@ module Chewy
         def bulk_body(action_objects, indexed_objects = nil)
           action_objects.inject([]) do |result, (action, objects)|
             method = "#{action}_bulk_entry"
-            result.concat(objects.map { |object| send(method, object, indexed_objects) }.flatten)
+            crutches = Chewy::Type::Crutch::Crutches.new self, objects
+            result.concat(objects.map { |object| send(method, object, indexed_objects, crutches) }.flatten)
           end
         end
 
-        def delete_bulk_entry(object, indexed_objects = nil)
+        def delete_bulk_entry(object, indexed_objects = nil, crutches = nil)
           entry = {}
 
           if self.root_object.id
@@ -102,7 +103,7 @@ module Chewy
           [{ delete: entry }]
         end
 
-        def index_bulk_entry(object, indexed_objects = nil)
+        def index_bulk_entry(object, indexed_objects = nil, crutches = nil)
           entry = {}
 
           if self.root_object.id
@@ -119,7 +120,7 @@ module Chewy
             existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
           end
 
-          entry[:data] = object_data(object)
+          entry[:data] = object_data(object, crutches)
 
           if existing_object && entry[:parent].to_s != existing_object[:parent]
             [{ delete: entry.except(:data).merge(parent: existing_object[:parent]) }, { index: entry }]
@@ -148,8 +149,8 @@ module Chewy
           end
         end
 
-        def object_data object
-          (self.root_object ||= build_root).compose(object)[type_name.to_sym]
+        def object_data object, crutches = nil
+          (self.root_object ||= build_root).compose(object, crutches)[type_name.to_sym]
         end
 
         def extract_errors result

data/lib/chewy/type/mapping.rb

@@ -154,7 +154,11 @@ module Chewy
       private
 
         def expand_nested field, &block
-          @_current_field.nested(field) if @_current_field
+          if @_current_field
+            field.parent = @_current_field
+            @_current_field.children.push(field)
+          end
+
           if block
             previous_field, @_current_field = @_current_field, field
             block.call
@@ -164,8 +168,8 @@ module Chewy
 
         def build_root options = {}, &block
           self.root_object = Chewy::Fields::Root.new(type_name, options)
-          expand_nested(self.root_object, &block)
-          @_current_field = self.root_object
+          expand_nested(root_object, &block)
+          @_current_field = root_object
         end
       end
     end

data/lib/chewy/type/observe.rb

@@ -3,52 +3,41 @@ module Chewy
     module Observe
       extend ActiveSupport::Concern
 
-      module MongoidMethods
-        def update_index(type_name, *args, &block)
-          options = args.extract_options!
-          method = args.first
-
-          update = Proc.new do
-            backreference = if method && method.to_s == 'self'
-              self
-            elsif method
-              send(method)
-            else
-              instance_eval(&block)
-            end
-
-            Chewy.derive_type(type_name).update_index(backreference, options)
+      def self.update_proc(type_name, *args, &block)
+        options = args.extract_options!
+        method = args.first
+
+        Proc.new do
+          backreference = if method && method.to_s == 'self'
+            self
+          elsif method
+            send(method)
+          else
+            instance_eval(&block)
           end
 
-          after_save &update
-          after_destroy &update
+          Chewy.derive_type(type_name).update_index(backreference, options)
         end
       end
 
-      module ActiveRecordMethods
+      module MongoidMethods
         def update_index(type_name, *args, &block)
-          options = args.extract_options!
-          method = args.first
+          update_proc = Observe.update_proc(type_name, *args, &block)
 
-          update = Proc.new do
-            # clear_association_cache if Chewy.strategy.current.name == :urgent
-
-            backreference = if method && method.to_s == 'self'
-              self
-            elsif method
-              send(method)
-            else
-              instance_eval(&block)
-            end
+          after_save &update_proc
+          after_destroy &update_proc
+        end
+      end
 
-            Chewy.derive_type(type_name).update_index(backreference, options)
-          end
+      module ActiveRecordMethods
+        def update_index(type_name, *args, &block)
+          update_proc = Observe.update_proc(type_name, *args, &block)
 
           if Chewy.use_after_commit_callbacks
-            after_commit &update
+            after_commit &update_proc
           else
-            after_save &update
-            after_destroy &update
+            after_save &update_proc
+            after_destroy &update_proc
           end
         end
       end

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.7.0'
+  VERSION = '0.8.0'
 end

data/spec/chewy/fields/base_spec.rb

@@ -14,9 +14,9 @@ describe Chewy::Fields::Base do
 
     context 'nested fields' do
       before do
-        field.nested(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
-        field.nested(described_class.new(:subname2, value: ->{ subvalue2 }))
-        field.nested(described_class.new(:subname3))
+        field.children.push(described_class.new(:subname1, value: ->(o){ o.subvalue1 }))
+        field.children.push(described_class.new(:subname2, value: ->{ subvalue2 }))
+        field.children.push(described_class.new(:subname3))
       end
 
       specify { expect(field.compose(double(value: double(subvalue1: 'hello', subvalue2: 'value', subname3: 'world'))))
@@ -32,8 +32,13 @@ describe Chewy::Fields::Base do
 
     context 'parent objects' do
       let!(:country) { described_class.new(:name, value: ->(country){ country.cities }) }
-      let!(:city) { country.nested(described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } })) }
-      let!(:district) { city.nested(described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] })) }
+      let!(:city) { described_class.new(:name, value: ->(city, country) { city.districts.map { |district| [district, country.name] } }) }
+      let!(:district) { described_class.new(:name, value: ->(district, city, country) { [district, city.name, country.name] }) }
+
+      before do
+        country.children.push(city)
+        city.children.push(district)
+      end
 
       specify { expect(country.compose(double(name: 'Thailand', cities: [
         double(name: 'Bangkok', districts: ['First', 'Second'])
@@ -48,8 +53,8 @@ describe Chewy::Fields::Base do
     context 'implicit values' do
       let(:field) { described_class.new(:name, type: 'string') }
       before do
-        field.nested(described_class.new(:name))
-        field.nested(described_class.new(:untouched))
+        field.children.push(described_class.new(:name))
+        field.children.push(described_class.new(:untouched))
       end
 
       specify { expect(field.compose(double(name: 'Alex'))).to eq({name: 'Alex'}) }
@@ -60,28 +65,21 @@ describe Chewy::Fields::Base do
       let(:object) { double(name: { key1: 'value1', key2: 'value2' }) }
 
       before do
-        field.nested(described_class.new(:key1, value: ->(h){ h[:key1] }))
-        field.nested(described_class.new(:key2, value: ->(h){ h[:key2] }))
+        field.children.push(described_class.new(:key1, value: ->(h){ h[:key1] }))
+        field.children.push(described_class.new(:key2, value: ->(h){ h[:key2] }))
       end
 
       specify{ expect(field.compose(object)).to eq({ name: { 'key1' => 'value1', 'key2' => 'value2' } }) }
     end
   end
 
-  describe '#nested' do
-    let(:field) { described_class.new(:name) }
-
-    specify { expect { field.nested(described_class.new(:name1)) }
-      .to change { field.nested[:name1] }.from(nil).to(an_instance_of(described_class))  }
-  end
-
   describe '#mappings_hash' do
     let(:field) { described_class.new(:name, type: :object) }
     let(:fields1) { 2.times.map { |i| described_class.new("name#{i+1}", type: "string#{i+1}") } }
     let(:fields2) { 2.times.map { |i| described_class.new("name#{i+3}", type: "string#{i+3}") } }
     before do
-      fields1.each { |m| field.nested(m) }
-      fields2.each { |m| fields1[0].nested(m) }
+      fields1.each { |m| field.children.push(m) }
+      fields2.each { |m| fields1[0].children.push(m) }
     end
 
     specify { expect(field.mappings_hash).to eq({name: {type: :object, properties: {
@@ -317,7 +315,16 @@ describe Chewy::Fields::Base do
         stub_model(:country)
 
         City.belongs_to :country
-        Country.has_many :cities
+
+        if active_record?
+          if ActiveRecord::VERSION::MAJOR >= 4
+            Country.has_many :cities, -> { order :id }
+          else
+            Country.has_many :cities, order: :id
+          end
+        else # mongoid
+          Country.has_many :cities, order: :id.asc
+        end
 
         stub_index(:countries) do
           define_type Country do

data/spec/chewy/query_spec.rb

@@ -39,6 +39,8 @@ describe Chewy::Query do
     specify { expect(subject.types(:product, :country).count).to eq(6) }
     specify { expect(subject.filter(term: {age: 10}).count).to eq(1) }
     specify { expect(subject.query(term: {age: 10}).count).to eq(1) }
+    specify { expect(subject.search_type(:count).count).to eq(0) }
+    specify { expect(subject.search_type(:count).total).to eq(9) }
   end
 
   describe '#==' do
@@ -101,6 +103,13 @@ describe Chewy::Query do
     specify { expect { subject.offset(10) }.not_to change { subject.criteria.request_options } }
   end
 
+  describe '#script_fields' do
+    specify { expect(subject.script_fields(distance: 'test()')).to be_a described_class }
+    specify { expect(subject.script_fields(distance: 'test()')).not_to eq(subject) }
+    specify { expect(subject.script_fields(distance: 'test()').criteria.script_fields).to include(distance: 'test()') }
+    specify { expect { subject.script_fields(distance: 'test()') }.not_to change { subject.criteria.script_fields } }
+  end
+
   describe '#script_score' do
     specify { expect(subject.script_score('23')).to be_a described_class }
     specify { expect(subject.script_score('23')).not_to eq(subject) }
@@ -422,6 +431,10 @@ describe Chewy::Query do
     specify { expect(subject.types([:product, :city]).types!(:country).criteria.types).to match_array(['country']) }
   end
 
+  describe '#search_type' do
+    specify { expect(subject.search_type(:count).options).to include(search_type: :count) }
+  end
+
   describe '#aggregations' do
     specify { expect(subject.aggregations(attribute: {terms: {field: 'attribute'}})).to be_a described_class }
     specify { expect(subject.aggregations(attribute: {terms: {field: 'attribute'}})).not_to eq(subject) }

data/spec/chewy/runtime_spec.rb

@@ -4,6 +4,6 @@ describe Chewy::Runtime do
   describe '.version' do
     specify { expect(described_class.version).to be_a(described_class::Version) }
     specify { expect(described_class.version).to be >= '1.0' }
-    specify { expect(described_class.version).to be < '1.5' }
+    specify { expect(described_class.version).to be < '1.6' }
   end
 end

data/spec/chewy/strategy/resque_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+if defined?(::Resque)
+  require 'resque_spec'
+
+  describe Chewy::Strategy::Resque 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)
+      end
+    end
+  end
+end

data/spec/chewy/strategy/sidekiq_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+if defined?(::Sidekiq)
+  require 'sidekiq/testing'
+
+  describe Chewy::Strategy::Sidekiq do
+    around { |example| Chewy.strategy(:bypass) { example.run } }
+    before { ::Sidekiq::Worker.clear_all }
+    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: :sidekiq)
+    end
+
+    specify do
+      ::Sidekiq::Testing.inline! do
+        expect { [city, other_city].map(&:save!) }
+          .to update_index(CitiesIndex::City, strategy: :sidekiq)
+          .and_reindex(city, other_city)
+      end
+    end
+  end
+end

data/spec/chewy/type/adapter/mongoid_spec.rb

@@ -41,10 +41,19 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     subject { described_class.new(City) }
     let!(:cities) { 3.times.map { City.create! } }
 
-    specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id)) }
-    specify { expect(subject.identify(cities)).to eq(cities.map(&:id)) }
-    specify { expect(subject.identify(cities.first)).to eq([cities.first.id]) }
-    specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id)) }
+    specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id).map(&:to_s)) }
+    specify { expect(subject.identify(cities)).to eq(cities.map(&:id).map(&:to_s)) }
+    specify { expect(subject.identify(cities.first)).to eq([cities.first.id.to_s]) }
+    specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id).map(&:to_s)) }
+
+    context 'non-bson ids' do
+      let!(:cities) { 3.times.map { |i| City.create! id: i+1 } }
+
+      specify { expect(subject.identify(City.all)).to match_array(cities.map(&:id)) }
+      specify { expect(subject.identify(cities)).to eq(cities.map(&:id)) }
+      specify { expect(subject.identify(cities.first)).to eq([cities.first.id]) }
+      specify { expect(subject.identify(cities.first(2).map(&:id))).to eq(cities.first(2).map(&:id)) }
+    end
   end
 
   describe '#import' do
@@ -59,7 +68,7 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
       let!(:deleted) { 4.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
       subject { described_class.new(City) }
 
-      specify { expect(import).to eq([{index: cities}]) }
+      specify { expect(import).to match([{index: match_array(cities)}]) }
       specify { expect(import nil).to eq([]) }
 
       specify { expect(import(City.order(:id.asc))).to eq([{index: cities}]) }
@@ -145,8 +154,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
     end
 
     context 'default scope' do
-      let!(:cities) { 4.times.map { |i| City.create!(rating: i/3) }.sort_by(&:id) }
-      let!(:deleted) { 3.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      let!(:cities) { 4.times.map { |i| City.create!(id: i, rating: i/3) }.sort_by(&:id) }
+      let!(:deleted) { 3.times.map { |i| City.create!(id: 4 + i).tap(&:destroy) }.sort_by(&:id) }
       subject { described_class.new(City.where(rating: 0)) }
 
       specify { expect(import).to eq([{index: cities.first(3)}]) }
@@ -242,8 +251,8 @@ describe Chewy::Type::Adapter::Mongoid, :mongoid do
 
   describe '#load' do
     context do
-      let!(:cities) { 3.times.map { |i| City.create!(rating: i/2) }.sort_by(&:id) }
-      let!(:deleted) { 2.times.map { |i| City.create!.tap(&:destroy) }.sort_by(&:id) }
+      let!(:cities) { 3.times.map { |i| City.create!(id: i, rating: i/2) }.sort_by(&:id) }
+      let!(:deleted) { 2.times.map { |i| City.create!(id: 3 + i).tap(&:destroy) }.sort_by(&:id) }
 
       let(:type) { double(type_name: 'user') }