chewy 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7aa20726080ec98870f97d0c0ef730a3eb7bc4f
-  data.tar.gz: 66b15afd916e7ed479bf7e9bacc3286a9ce9dc25
+  metadata.gz: f9741190c8e67f2cf5a4ae0a7270eb7716884b70
+  data.tar.gz: fc86af473569d271c43d3b39cd0f710234adae76
 SHA512:
-  metadata.gz: 5800f28ff7480f5c7052c5860a5b3f3e6547ebee02e88f82d59e4aa2df6764d3330ee5c00ee3b36cff26c74ebec5d3713641868618d465718c6c615bae12ef85
-  data.tar.gz: eb17d5fa79ec63472fdb0adac109d8612af6a9693bcda2afe05efe20f32b9d221933403049ba27731a9410752e6c955e522fceab4e7d6c372b38b64f21d87708
+  metadata.gz: 50ee0a42f751e1aba5639b139e236056aa067f07524eb7d3d1c7bfc80f47b73ad8d7c9f5ae4df2cceda03d9b22d1896def3dc311c9f348e17bfec241bdb6102d
+  data.tar.gz: bee6ca569f2568ab4c33f3fcc23ffca5e5cb121a1145a07e8dcb9f09a0d5333999e454f2ff220621b2aebaf14dc29a9ba4254e0e6cb0f195d8c83fd2d9a1a942

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # master
 
+# Version 0.10.1
+
+## Changes
+
+  * Improved parallel worker titles (#558)
+
+## Bugfixes
+
+  * Fixed request strategy initial debug message (#557)
+
+  * Fixed will objects paginated array initialization when pagination was not used (#556)
+
+  * Fixed fields symbol/string value (#555)
+
+  * Fixed root field value proc (#554)
+
+# Version 0.10.0
+
 ## Breaking changes
 
   * Changed behavior of `Chewy::Index.index_name`, it doesn't cache the values anymore.
@@ -8,7 +26,9 @@
 
 ## Changes
 
-  * Parallel import and rake tasks.
+  * Less noisy strategies logging (@Borzik, #543)
+
+  * Parallel import and the corresponding rake tasks.
 
   * `:shoryuken` async strategy (@josephchoe, #532)
 

data/README.md

@@ -228,7 +228,7 @@ If you would like to use AWS's ElasticSearch using an IAM user policy, you will
   ```
 
   [See index settings here](https://www.elastic.co/guide/en/elasticsearch/reference/current/indices-update-settings.html).
-  [See root object settings here](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-root-object-type.html).
+  [See root object settings here](https://www.elastic.co/guide/en/elasticsearch/reference/current/dynamic-field-mapping.html).
 
   See [mapping.rb](lib/chewy/type/mapping.rb) for more details.
 
@@ -357,7 +357,7 @@ end
 ```
 ### Geo Point fields
 
-You can use [Elasticsearch's geo mapping](https://www.elastic.co/guide/en/elasticsearch/reference/current/mapping-geo-point-type.html) with the `geo_point` field type, allowing you to query, filter and order by latitude and longitude. You can use the following hash format:
+You can use [Elasticsearch's geo mapping](https://www.elastic.co/guide/en/elasticsearch/reference/current/geo-point.html) with the `geo_point` field type, allowing you to query, filter and order by latitude and longitude. You can use the following hash format:
 
 ```ruby
 field :coordinates, type: 'geo_point', value: ->{ {lat: latitude, lon: longitude} }

data/lib/chewy/fields/base.rb

@@ -32,34 +32,14 @@ module Chewy
       end
 
       def compose(*objects)
-        object = objects.first
+        result = evaluate(objects)
 
-        result =
-          if value && value.is_a?(Proc)
-            if value.arity.zero?
-              object.instance_exec(&value)
-            elsif value.arity < 0
-              value.call(*object)
-            else
-              value.call(*objects.first(value.arity))
-            end
-          elsif object.is_a?(Hash)
-            if object.key?(name)
-              object[name]
-            else
-              object[name.to_s]
-            end
+        if children.present? && !multi_field?
+          result = if result.respond_to?(:to_ary)
+            result.to_ary.map { |item| compose_children(item, *objects) }
           else
-            object.send(name)
+            compose_children(result, *objects)
           end
-
-        if children.present? && !multi_field?
-          result =
-            if result.respond_to?(:to_ary)
-              result.to_ary.map { |item| compose_children(item, *objects) }
-            else
-              compose_children(result, *objects)
-            end
         end
 
         {name => result}
@@ -67,6 +47,32 @@ module Chewy
 
     private
 
+      def evaluate(objects)
+        object = objects.first
+
+        if value.is_a?(Proc)
+          if value.arity.zero?
+            object.instance_exec(&value)
+          elsif value.arity < 0
+            value.call(*object)
+          else
+            value.call(*objects.first(value.arity))
+          end
+        else
+          message = value.is_a?(Symbol) || value.is_a?(String) ? value.to_sym : name
+
+          if object.is_a?(Hash)
+            if object.key?(message)
+              object[message]
+            else
+              object[message.to_s]
+            end
+          else
+            object.send(message)
+          end
+        end
+      end
+
       def compose_children(value, *parent_objects)
         return unless value
 

data/lib/chewy/fields/root.rb

@@ -12,6 +12,7 @@ module Chewy
         @id = @options.delete(:id) || options.delete(:_id)
         @parent = @options.delete(:parent) || options.delete(:_parent)
         @parent_id = @options.delete(:parent_id)
+        @value ||= -> { self }
         @dynamic_templates = []
         @options.delete(:type)
       end
@@ -67,6 +68,8 @@ module Chewy
       # @param fields [Array<Symbol>] a list of fields to compose, every field will be composed if empty
       # @return [Hash] JSON-ready heash with stringifyed keys
       def compose(object, crutches = nil, fields: [])
+        result = evaluate([object, crutches])
+
         if children.present?
           child_fields = if fields.present?
             child_hash.slice(*fields).values
@@ -74,13 +77,13 @@ module Chewy
             children
           end
 
-          child_fields.each_with_object({}) do |field, result|
-            result.merge!(field.compose(object, crutches) || {})
+          child_fields.each_with_object({}) do |field, memo|
+            memo.merge!(field.compose(result, crutches) || {})
           end.as_json
         elsif fields.present?
-          object.as_json(only: fields)
+          result.as_json(only: fields)
         else
-          object.as_json
+          result.as_json
         end
       end
 

data/lib/chewy/railtie.rb

@@ -7,7 +7,6 @@ module Chewy
     class RequestStrategy
       def initialize(app)
         @app = app
-        Chewy.logger.debug("Chewy strategies stack: [1] <- #{Chewy.request_strategy}")
       end
 
       def call(env)
@@ -15,6 +14,8 @@ module Chewy
         if Rails.application.config.respond_to?(:assets) && env['PATH_INFO'].start_with?(Rails.application.config.assets.prefix)
           @app.call(env)
         else
+          Chewy.logger.info("Chewy request strategy is `#{Chewy.request_strategy}`") if @request_strategy != Chewy.request_strategy
+          @request_strategy = Chewy.request_strategy
           Chewy.strategy(Chewy.request_strategy) { @app.call(env) }
         end
       end
@@ -49,6 +50,7 @@ module Chewy
       else
         Chewy.strategy(:urgent)
       end
+      Chewy.logger.info("Chewy console strategy is `#{Chewy.strategy.current.name}`")
     end
 
     initializer 'chewy.logger', after: 'active_record.logger' do

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

@@ -31,7 +31,9 @@ module Chewy
       private
 
         def paginated_collection(collection)
-          ::WillPaginate::Collection.create(current_page, per_page, total_entries) do |pager|
+          page = current_page || 1
+          per = per_page || ::WillPaginate.per_page
+          ::WillPaginate::Collection.create(page, per, total_entries) do |pager|
             pager.replace collection
           end
         end

data/lib/chewy/type/import.rb

@@ -8,8 +8,8 @@ module Chewy
     module Import
       extend ActiveSupport::Concern
 
-      IMPORT_WORKER = lambda do |type, options, ids|
-        ::Process.setproctitle("chewy import #{type}[#{::Parallel.worker_number}]")
+      IMPORT_WORKER = lambda do |type, options, total, ids, index|
+        ::Process.setproctitle("chewy [#{type}]: import data (#{index + 1}/#{total})")
         routine = Routine.new(type, options)
         type.adapter.import(*ids, routine.options) do |action_objects|
           routine.process(**action_objects)
@@ -17,8 +17,8 @@ module Chewy
         {errors: routine.errors, import: routine.stats, leftovers: routine.leftovers}
       end
 
-      LEFTOVERS_WORKER = lambda do |type, options, body|
-        ::Process.setproctitle("chewy import #{type}[#{::Parallel.worker_number}]")
+      LEFTOVERS_WORKER = lambda do |type, options, total, body, index|
+        ::Process.setproctitle("chewy [#{type}]: import leftovers (#{index + 1}/#{total})")
         routine = Routine.new(type, options)
         routine.perform_bulk(body)
         routine.errors
@@ -155,13 +155,13 @@ module Chewy
             batches = adapter.import_references(*objects, routine.options.slice(:batch_size)).to_a
 
             ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-            results = ::Parallel.map(batches, routine.parallel_options, &IMPORT_WORKER.curry[self, routine.options])
+            results = ::Parallel.map_with_index(batches, routine.parallel_options, &IMPORT_WORKER.curry[self, routine.options, batches.size])
             ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
             errors, import, leftovers = process_parallel_import_results(results)
 
             if leftovers.present?
               batches = leftovers.each_slice(routine.options[:batch_size])
-              results = ::Parallel.map(batches, routine.parallel_options, &LEFTOVERS_WORKER.curry[self, routine.options])
+              results = ::Parallel.map_with_index(batches, routine.parallel_options, &LEFTOVERS_WORKER.curry[self, routine.options, batches.size])
               errors.concat(results.flatten(1))
             end
 

data/lib/chewy/type/syncer.rb

@@ -28,7 +28,8 @@ module Chewy
     class Syncer
       DEFAULT_SYNC_BATCH_SIZE = 20_000
       ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      OUTDATED_IDS_WORKER = lambda do |outdated_sync_field_type, source_data_hash, index_data|
+      OUTDATED_IDS_WORKER = lambda do |outdated_sync_field_type, source_data_hash, type, total, index_data|
+        ::Process.setproctitle("chewy [#{type}]: sync outdated calculation (#{::Parallel.worker_number + 1}/#{total})") if type
         index_data.each_with_object([]) do |(id, index_sync_value), result|
           next unless source_data_hash[id]
 
@@ -41,14 +42,15 @@ module Chewy
           result.push(id) if outdated
         end
       end
-      SOURCE_OR_INDEX_DATA_WORKER = lambda do |syncer, type|
-        result = case type
+      SOURCE_OR_INDEX_DATA_WORKER = lambda do |syncer, type, kind|
+        ::Process.setproctitle("chewy [#{type}]: sync fetching data (#{kind})")
+        result = case kind
         when :source
           syncer.send(:fetch_source_data)
         when :index
           syncer.send(:fetch_index_data)
         end
-        {type => result}
+        {kind => result}
       end
 
       def self.typecast_date(string)
@@ -143,7 +145,7 @@ module Chewy
         @source_and_index_data ||= begin
           if @parallel
             ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-            result = ::Parallel.map(%i[source index], @parallel, &SOURCE_OR_INDEX_DATA_WORKER.curry[self])
+            result = ::Parallel.map(%i[source index], @parallel, &SOURCE_OR_INDEX_DATA_WORKER.curry[self, @type])
             ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
             if result.first.keys.first == :source
               [result.first.values.first, result.second.values.first]
@@ -182,7 +184,7 @@ module Chewy
       end
 
       def linear_outdated_ids
-        OUTDATED_IDS_WORKER.call(outdated_sync_field_type, source_data.to_h, index_data)
+        OUTDATED_IDS_WORKER.call(outdated_sync_field_type, source_data.to_h, nil, nil, index_data)
       end
 
       def parallel_outdated_ids
@@ -190,7 +192,7 @@ module Chewy
         batches = index_data.each_slice(size)
 
         ::ActiveRecord::Base.connection.close if defined?(::ActiveRecord::Base)
-        result = ::Parallel.map(batches, @parallel, &OUTDATED_IDS_WORKER.curry[outdated_sync_field_type, source_data.to_h]).flatten(1)
+        result = ::Parallel.map(batches, @parallel, &OUTDATED_IDS_WORKER.curry[outdated_sync_field_type, source_data.to_h, @type, batches.size]).flatten(1)
         ::ActiveRecord::Base.connection.reconnect! if defined?(::ActiveRecord::Base)
         result
       end

data/lib/chewy/type/witchcraft.rb

@@ -102,14 +102,16 @@ module Chewy
               (if #{object}.is_a?(Hash)
                 {
                   #{non_proc_fields.map do |f|
-                    fetcher = "#{object}.has_key?(:#{f.name}) ? #{object}[:#{f.name}] : #{object}['#{f.name}']"
+                    key_name = f.value.is_a?(Symbol) || f.value.is_a?(String) ? f.value : f.name
+                    fetcher = "#{object}.has_key?(:#{key_name}) ? #{object}[:#{key_name}] : #{object}['#{key_name}']"
                     "'#{f.name}'.freeze => #{composed_value(f, fetcher, nesting)}"
                   end.join(', ')}
                 }
               else
                 {
                   #{non_proc_fields.map do |f|
-                    "'#{f.name}'.freeze => #{composed_value(f, "#{object}.#{f.name}", nesting)}"
+                    method_name = f.value.is_a?(Symbol) || f.value.is_a?(String) ? f.value : f.name
+                    "'#{f.name}'.freeze => #{composed_value(f, "#{object}.#{method_name}", nesting)}"
                   end.join(', ')}
                 }
               end)
@@ -137,7 +139,7 @@ module Chewy
 
         def non_proc_fields_for(parent, nesting)
           return [] unless parent
-          fields = (parent.children || []).reject { |field| field.value && field.value.is_a?(Proc) }
+          fields = (parent.children || []).reject { |field| field.value.is_a?(Proc) }
 
           if nesting.zero? && @fields.present?
             fields.select { |f| @fields.include?(f.name) }
@@ -148,7 +150,7 @@ module Chewy
 
         def proc_fields_for(parent, nesting)
           return [] unless parent
-          fields = (parent.children || []).select { |field| field.value && field.value.is_a?(Proc) }
+          fields = (parent.children || []).select { |field| field.value.is_a?(Proc) }
 
           if nesting.zero? && @fields.present?
             fields.select { |f| @fields.include?(f.name) }

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '0.10.0'.freeze
+  VERSION = '0.10.1'.freeze
 end

data/spec/chewy/fields/base_spec.rb

@@ -10,6 +10,8 @@ describe Chewy::Fields::Base do
     specify { expect(field.compose(double(value: 'hello'))).to eq(name: 'hello') }
     specify { expect(field.compose(double(value: %w[hello world]))).to eq(name: %w[hello world]) }
 
+    specify { expect(described_class.new(:name, value: :last_name).compose(double(last_name: 'hello'))).to eq(name: 'hello') }
+    specify { expect(described_class.new(:name, value: :last_name).compose('last_name' => 'hello')).to eq(name: 'hello') }
     specify { expect(described_class.new(:name).compose(double(name: 'hello'))).to eq(name: 'hello') }
     specify { expect(described_class.new(:false_value).compose(false_value: false)).to eq(false_value: false) }
     specify { expect(described_class.new(:true_value).compose(true_value: true)).to eq(true_value: true) }

data/spec/chewy/fields/root_spec.rb

@@ -82,6 +82,53 @@ describe Chewy::Fields::Root do
           .to eq('name' => 'London')
       end
     end
+
+    context 'root value provided' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            root value: ->(o) { {name: o.name + 'Modified', rating: o.rating.next} }
+          end
+        end
+      end
+
+      let(:city) { double(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.send(:build_root).compose(city))
+          .to eq('name' => 'LondonModified', 'rating' => 101)
+      end
+
+      specify do
+        expect(PlacesIndex::City.send(:build_root).compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'LondonModified')
+      end
+    end
+
+    context 'complex evaluations' do
+      before do
+        stub_index(:places) do
+          define_type :city do
+            root value: ->(o) { {name: o.name + 'Modified', rating: o.rating.next} } do
+              field :name, value: ->(o) { o[:name] + 'Modified' }
+              field :rating
+            end
+          end
+        end
+      end
+
+      let(:city) { double(name: 'London', rating: 100) }
+
+      specify do
+        expect(PlacesIndex::City.send(:build_root).compose(city))
+          .to eq('name' => 'LondonModifiedModified', 'rating' => 101)
+      end
+
+      specify do
+        expect(PlacesIndex::City.send(:build_root).compose(city, fields: %i[name borogoves]))
+          .to eq('name' => 'LondonModifiedModified')
+      end
+    end
   end
 
   describe '#child_hash' do

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

@@ -3,13 +3,17 @@ require 'chewy/search/pagination/kaminari_examples'
 describe Chewy::Search::Pagination::Kaminari do
   it_behaves_like :kaminari, Chewy::Search::Request do
     describe '#objects' do
-      let(:data) { Array.new(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      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(::Kaminari.config).to receive_messages(default_per_page: 3) }
+      before { allow(::Kaminari.config).to receive_messages(default_per_page: 17) }
 
+      specify { expect(search.objects.class).to eq(Kaminari::PaginatableArray) }
+      specify { expect(search.objects.total_count).to eq(12) }
+      specify { expect(search.objects.limit_value).to eq(17) }
+      specify { expect(search.objects.offset_value).to eq(0) }
       specify { expect(search.per(2).page(3).objects.class).to eq(Kaminari::PaginatableArray) }
-      specify { expect(search.per(2).page(3).objects.total_count).to eq(10) }
+      specify { expect(search.per(2).page(3).objects.total_count).to eq(12) }
       specify { expect(search.per(2).page(3).objects.limit_value).to eq(2) }
       specify { expect(search.per(2).page(3).objects.offset_value).to eq(4) }
     end

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

@@ -3,13 +3,19 @@ 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(10) { |i| {id: i.next.to_s, name: "Name#{i.next}", age: 10 * i.next}.stringify_keys! } }
+      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: 3) }
+      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(10) }
+      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

data/spec/chewy/type/witchcraft_spec.rb

@@ -212,5 +212,21 @@ describe Chewy::Type::Witchcraft do
         specify { expect(type.cauldron.brew(object)).to eq(attributes.as_json) }
       end
     end
+
+    context 'symbol value' do
+      mapping do
+        field :name, value: :last_name
+      end
+
+      context do
+        let(:object) { double(last_name: 'Name') }
+        specify { expect(type.cauldron.brew(object)).to eq({name: 'Name'}.as_json) }
+      end
+
+      context do
+        let(:object) { {'last_name' => 'Name'} }
+        specify { expect(type.cauldron.brew(object)).to eq({name: 'Name'}.as_json) }
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - pyromaniac
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-27 00:00:00.000000000 Z
+date: 2017-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake