chewy 0.7.0 → 0.8.0

data/gemfiles/rails.4.2.activerecord.kaminari.gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gem "activerecord", "~> 4.2.0"
 gem "activesupport", "~> 4.2.0"
-gem "kaminari", :require => false
+gem "kaminari", "0.16.3", :require => false
 
 group :test do
   gem "guard"

data/gemfiles/rails.4.2.mongoid.gemfile

@@ -4,6 +4,8 @@ source "https://rubygems.org"
 
 gem "mongoid", "~> 4.0.0"
 gem "activesupport", "~> 4.2.0"
+gem "resque", :require => false
+gem "sidekiq", :require => false
 
 group :test do
   gem "guard"

data/gemfiles/rails.4.2.mongoid.kaminari.gemfile

@@ -4,7 +4,7 @@ source "https://rubygems.org"
 
 gem "mongoid", "~> 4.0.0"
 gem "activesupport", "~> 4.2.0"
-gem "kaminari", :require => false
+gem "kaminari", "0.16.3", :require => false
 
 group :test do
   gem "guard"

data/lib/chewy.rb

@@ -21,6 +21,7 @@ require 'chewy/index'
 require 'chewy/type'
 require 'chewy/fields/base'
 require 'chewy/fields/root'
+require 'chewy/railtie' if defined?(::Rails)
 
 begin
   require 'kaminari'
@@ -35,8 +36,6 @@ begin
 rescue LoadError
 end
 
-require 'chewy/railtie' if defined?(::Rails)
-
 ActiveSupport.on_load(:active_record) do
   extend Chewy::Type::Observe::ActiveRecordMethods
 

data/lib/chewy/config.rb

@@ -25,9 +25,9 @@ module Chewy
       #
       :root_strategy,
 
-      # The first trategy in stack. `:base` by default.
-      # If you neet to return to the previous chewy behavior -
-      # just set it to `:bypass`
+      # Default request strategy middleware, used in e.g
+      # Rails controllers. See Chewy::Railtie::RequestStrategy
+      # for more info.
       #
       :request_strategy,
 

data/lib/chewy/fields/base.rb

@@ -1,29 +1,43 @@
 module Chewy
   module Fields
     class Base
-      attr_reader :name, :options, :value
+      attr_reader :name, :options, :value, :children
+      attr_accessor :parent
 
       def initialize(name, options = {})
-        @name, @options, @nested = name.to_sym, options.deep_symbolize_keys, {}
+        @name, @options = name.to_sym, options.deep_symbolize_keys
         @value = @options.delete(:value)
+        @children = []
       end
 
       def multi_field?
-        nested.any? && !object_field?
+        children.any? && !object_field?
       end
 
       def object_field?
-        (nested.any? && options[:type].blank?) || ['object', 'nested'].include?(options[:type].to_s)
+        (children.any? && options[:type].blank?) || ['object', 'nested'].include?(options[:type].to_s)
       end
 
-      def root_field?
-        false
+      def mappings_hash
+        mapping = children.any? ? {
+          (multi_field? ? :fields : :properties) => children.map(&:mappings_hash).inject(:merge)
+        } : {}
+        mapping.reverse_merge!(options)
+        mapping.reverse_merge!(type: (children.any? ? 'object' : 'string'))
+        {name => mapping}
       end
 
       def compose(object, *parent_objects)
+        objects = ([object] + parent_objects.flatten).uniq
+
         result = if value && value.is_a?(Proc)
-          value.arity.zero? ? object.instance_exec(&value) :
-            value.call(object, *parent_objects.first(value.arity - 1))
+          if value.arity == 0
+            object.instance_exec(&value)
+          elsif value.arity < 0
+            value.call(*object)
+          else
+            value.call(*objects.first(value.arity))
+          end
         elsif object.is_a?(Hash)
           object[name] || object[name.to_s]
         else
@@ -31,35 +45,18 @@ module Chewy
         end
 
         result = if result.respond_to?(:to_ary)
-          result.to_ary.map { |result| nested_compose(result, object, *parent_objects) }
+          result.to_ary.map { |result| compose_children(result, *objects) }
         else
-          nested_compose(result, object, *parent_objects)
-        end if nested.any? && !multi_field?
+          compose_children(result, *objects)
+        end if children.any? && !multi_field?
 
         {name => result.as_json(root: false)}
       end
 
-      def nested(field = nil)
-        if field
-          @nested[field.name] = field
-        else
-          @nested
-        end
-      end
-
-      def mappings_hash
-        mapping = nested.any? ? {
-          (multi_field? ? :fields : :properties) => nested.values.map(&:mappings_hash).inject(:merge)
-        } : {}
-        mapping.reverse_merge!(options)
-        mapping.reverse_merge!(type: (nested.any? ? 'object' : 'string')) unless root_field?
-        {name => mapping}
-      end
-
     private
 
-      def nested_compose(value, *parent_objects)
-        nested.values.map { |field| field.compose(value, *parent_objects) if value }.compact.inject(:merge)
+      def compose_children(value, *parent_objects)
+        children.map { |field| field.compose(value, *parent_objects) if value }.compact.inject(:merge)
       end
     end
   end

data/lib/chewy/fields/root.rb

@@ -6,30 +6,20 @@ module Chewy
       attr_reader :parent
       attr_reader :parent_id
 
-      def initialize(name, options = {})
-        @id = options.delete(:id) || options.delete(:_id)
-        @parent = options.delete(:parent) || options.delete(:_parent)
-        @parent_id = options.delete(:parent_id)
-        options.reverse_merge!(value: ->(_) { _ })
-        super(name, options)
-        options.delete(:type)
-        @dynamic_templates = []
-      end
-
-      def multi_field?
-        false
-      end
+      def initialize(*args)
+        super(*args)
 
-      def object_field?
-        true
-      end
-
-      def root_field?
-        true
+        @id = @options.delete(:id) || options.delete(:_id)
+        @parent = @options.delete(:parent) || options.delete(:_parent)
+        @parent_id = @options.delete(:parent_id)
+        @value ||= ->(_) { _ }
+        @dynamic_templates = []
+        @options.delete(:type)
       end
 
       def mappings_hash
         mappings = super
+        mappings[name].delete(:type)
 
         if dynamic_templates.any?
           mappings[name][:dynamic_templates] ||= []

data/lib/chewy/query.rb

@@ -73,6 +73,20 @@ module Chewy
       chain { criteria.update_request_options explain: (value.nil? ? true : value) }
     end
 
+    # Adds <tt>script_fields</tt> parameter to search request.
+    #  UsersIndex.script_fields(
+    #    distance: {
+    #      params: {
+    #        lat: 37.569976,
+    #        lon: -122.351591
+    #      },
+    #      script: "doc['coordinates'].distanceInMiles(lat, lon)"
+    #    }
+    #  )
+    def script_fields value
+      chain { criteria.update_script_fields(value) }
+    end
+
     # Sets query compilation mode for search request.
     # Not used if only one filter for search is specified.
     # Possible values:
@@ -818,6 +832,20 @@ module Chewy
       chain { criteria.update_types params, purge: true }
     end
 
+    # Sets <tt>search_type</tt> for request.
+    # For instance, one can use <tt>search_type=count</tt> to fetch only total count of records or to fetch only aggregations without fetching records.
+    #
+    #   scope = UsersIndex.search_type(:count)
+    #   scope.count == 0  # no records actually fetched
+    #   scope.total == 10 # but we know a total count of them
+    #
+    #   scope = UsersIndex.aggs(max_age: { max: { field: 'age' } }).search_type(:count)
+    #   max_age = scope.aggs['max_age']['value']
+    #
+    def search_type val
+      chain { options.merge!(search_type: val) }
+    end
+
     # Merges two queries.
     # Merges all the values in criteria with the same rules as values added manually.
     #
@@ -909,7 +937,12 @@ module Chewy
     end
 
     def _request
-      @_request ||= criteria.request_body.merge(index: _indexes.map(&:index_name), type: _types.map(&:type_name))
+      @_request ||= begin
+        request = criteria.request_body
+        request.merge!(index: _indexes.map(&:index_name), type: _types.map(&:type_name))
+        request.merge!(search_type: options[:search_type]) if options[:search_type]
+        request
+      end
     end
 
     def _response

data/lib/chewy/railtie.rb

@@ -50,6 +50,7 @@ module Chewy
     initializer 'chewy.migration_strategy' do
       ActiveSupport.on_load(:active_record) do
         ActiveRecord::Migration.send(:include, MigrationStrategy)
+        ActiveRecord::Migrator.send(:include, MigrationStrategy) if defined? ActiveRecord::Migrator
       end
     end
 

data/lib/chewy/rspec/update_index.rb

@@ -100,12 +100,14 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
 
     type = Chewy.derive_type(type_name)
 
-    allow(type).to receive(:bulk) do |bulk_options|
-      @updated += bulk_options[:body].map do |updated_document|
-        updated_document.deep_symbolize_keys
+    instance_eval <<-RUBY
+       #{agnostic_stub} do |bulk_options|
+        @updated += bulk_options[:body].map do |updated_document|
+          updated_document.deep_symbolize_keys
+        end
+        {}
       end
-      {}
-    end
+    RUBY
 
     ActiveSupport::Deprecation.warn('`atomic: false` option is removed and not effective anymore, use `strategy: :atomic` option instead') if options.key?(:atomic)
     Chewy.strategy(options[:strategy] || :atomic) { block.call }
@@ -191,6 +193,14 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
   end
 
+  def agnostic_stub
+    if defined? Mocha
+      "type.stubs(:bulk).with"
+    else
+      "allow(type).to receive(:bulk)"
+    end
+  end
+
   def extract_documents *args
     options = args.extract_options!
 
@@ -231,4 +241,4 @@ RSpec::Matchers.define :update_index do |type_name, options = {}|
     end
     difference.none?
   end
-end
+end

data/lib/chewy/strategy.rb

@@ -3,6 +3,18 @@ require 'chewy/strategy/bypass'
 require 'chewy/strategy/urgent'
 require 'chewy/strategy/atomic'
 
+begin
+  require 'resque'
+  require 'chewy/strategy/resque'
+rescue LoadError
+end
+
+begin
+  require 'sidekiq'
+  require 'chewy/strategy/sidekiq'
+rescue LoadError
+end
+
 module Chewy
   # This class represents strategies stack with `:base`
   # Strategy on top of it. This causes raising exceptions

data/lib/chewy/strategy/atomic.rb

@@ -24,7 +24,7 @@ module Chewy
       end
 
       def leave
-        @stash.all? { |type, ids| type.import(ids) }
+        @stash.all? { |type, ids| type.import!(ids) }
       end
     end
   end

data/lib/chewy/strategy/resque.rb

@@ -0,0 +1,26 @@
+module Chewy
+  class Strategy
+    # The strategy works the same way as atomic, but performs
+    # async index update driven by resque
+    #
+    #   Chewy.strategy(:resque) do
+    #     User.all.map(&:save) # Does nothing here
+    #     Post.all.map(&:save) # And here
+    #     # It imports all the changed users and posts right here
+    #   end
+    #
+    class Resque < Atomic
+      class Worker
+        @queue = :chewy
+
+        def self.perform(type, ids)
+          type.constantize.import!(ids)
+        end
+      end
+
+      def leave
+        @stash.all? { |type, ids| ::Resque.enqueue(Chewy::Strategy::Resque::Worker, type.name, ids) }
+      end
+    end
+  end
+end

data/lib/chewy/strategy/sidekiq.rb

@@ -0,0 +1,26 @@
+module Chewy
+  class Strategy
+    # The strategy works the same way as atomic, but performs
+    # async index update driven by sidekiq
+    #
+    #   Chewy.strategy(:sidekiq) do
+    #     User.all.map(&:save) # Does nothing here
+    #     Post.all.map(&:save) # And here
+    #     # It imports all the changed users and posts right here
+    #   end
+    #
+    class Sidekiq < Atomic
+      class Worker
+        include ::Sidekiq::Worker
+
+        def perform(type, ids)
+          type.constantize.import!(ids)
+        end
+      end
+
+      def leave
+        @stash.all? { |type, ids| Chewy::Strategy::Sidekiq::Worker.perform_async(type.name, ids) }
+      end
+    end
+  end
+end

data/lib/chewy/strategy/urgent.rb

@@ -10,7 +10,7 @@ module Chewy
     #
     class Urgent < Base
       def update type, objects, options = {}
-        type.import(Array.wrap(objects))
+        type.import!(Array.wrap(objects))
       end
     end
   end

data/lib/chewy/type.rb

@@ -3,6 +3,7 @@ require 'chewy/type/mapping'
 require 'chewy/type/wrapper'
 require 'chewy/type/observe'
 require 'chewy/type/actions'
+require 'chewy/type/crutch'
 require 'chewy/type/import'
 require 'chewy/type/adapter/object'
 require 'chewy/type/adapter/active_record'
@@ -15,6 +16,7 @@ module Chewy
     include Wrapper
     include Observe
     include Actions
+    include Crutch
     include Import
 
     singleton_class.delegate :index_name, :client, to: :index

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

@@ -16,7 +16,7 @@ module Chewy
         end
 
         def import_scope(scope, batch_size)
-          scope = scope.reorder(target.primary_key.to_sym).limit(batch_size)
+          scope = scope.reorder(target_id.asc).limit(batch_size)
 
           ids = pluck_ids(scope)
           result = true
@@ -24,7 +24,7 @@ module Chewy
           while ids.any?
             result &= yield grouped_objects(default_scope_where_ids_in(ids))
             break if ids.size < batch_size
-            ids = pluck_ids(scope.where(scope.table[target.primary_key].gt(ids.last)))
+            ids = pluck_ids(scope.where(target_id.gt(ids.last)))
           end
 
           result
@@ -35,13 +35,17 @@ module Chewy
         end
 
         def scope_where_ids_in(scope, ids)
-          scope.where(target.primary_key => ids)
+          scope.where(target_id.in(Array.wrap(ids)))
         end
 
         def all_scope
           target.where(nil)
         end
 
+        def target_id
+          target.arel_table[target.primary_key]
+        end
+
         def relation_class
           ::ActiveRecord::Relation
         end

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

@@ -4,6 +4,11 @@ module Chewy
   class Type
     module Adapter
       class Mongoid < Orm
+
+        def identify collection
+          super(collection).map { |id| id.is_a?(BSON::ObjectId) ? id.to_s : id }
+        end
+
       private
 
         def cleanup_default_scope!