chewy 0.0.1 → 0.1.0

data/lib/chewy/query/nodes/script.rb

@@ -0,0 +1,20 @@
+module Chewy
+  class Query
+    module Nodes
+      class Script < Expr
+        def initialize script, params = {}
+          @script = script
+          @params = params
+          @options = params.extract!(:cache)
+        end
+
+        def __render__
+          script = {script: @script}
+          script.merge!(params: @params) if @params.present?
+          script.merge!(_cache: !!@options[:cache]) if @options.key?(:cache)
+          {script: script}
+        end
+      end
+    end
+  end
+end

data/lib/chewy/query/pagination.rb

@@ -1,38 +1,44 @@
-require 'kaminari'
-
 module Chewy
   class Query
     module Pagination
       extend ActiveSupport::Concern
 
       included do
-        include Kaminari::PageScopeMethods
+        include Kaminari if defined?(::Kaminari)
+      end
 
-        delegate :default_per_page, :max_per_page, :max_pages, to: :_kaminari_config
+      module Kaminari
+        extend ActiveSupport::Concern
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{Kaminari.config.page_method_name}(num = 1)
-            limit(limit_value).offset(limit_value * ([num.to_i, 1].max - 1))
-          end
-        RUBY
-      end
+        included do
+          include ::Kaminari::PageScopeMethods
 
-      def total_count
-        _response['hits']['total']
-      end
+          delegate :default_per_page, :max_per_page, :max_pages, to: :_kaminari_config
 
-      def limit_value
-        (criteria.search[:size].presence || default_per_page).to_i
-      end
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{::Kaminari.config.page_method_name}(num = 1)
+              limit(limit_value).offset(limit_value * ([num.to_i, 1].max - 1))
+            end
+          RUBY
+        end
 
-      def offset_value
-        criteria.search[:from].to_i
-      end
+        def total_count
+          _response['hits']['total']
+        end
+
+        def limit_value
+          (criteria.options[:size].presence || default_per_page).to_i
+        end
+
+        def offset_value
+          criteria.options[:from].to_i
+        end
 
-    private
+      private
 
-      def _kaminari_config
-        Kaminari.config
+        def _kaminari_config
+          ::Kaminari.config
+        end
       end
     end
   end

data/lib/chewy/railtie.rb

@@ -0,0 +1,23 @@
+module Chewy
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'tasks/chewy.rake'
+    end
+
+    initializer 'chewy.add_app_chewy_path' do |app|
+      app.config.paths.add 'app/chewy'
+    end
+
+    initializer 'chewy.add_requests_logging' do |app|
+      ActiveSupport::Notifications.subscribe('import_objects.chewy') do |name, start, finish, id, payload|
+        duration = ((finish - start).to_f * 10000).round / 10.0
+        Rails.logger.debug("  \e[1m\e[33m#{payload[:type]} Import (#{duration}ms)\e[0m #{payload[:import]}")
+      end
+
+      ActiveSupport::Notifications.subscribe('search_query.chewy') do |name, start, finish, id, payload|
+        duration = ((finish - start).to_f * 10000).round / 10.0
+        Rails.logger.debug("  \e[1m\e[33m#{payload[:index]} Search (#{duration}ms)\e[0m #{payload[:request]}")
+      end
+    end
+  end
+end

data/lib/chewy/rspec/update_index.rb

@@ -1,4 +1,4 @@
-RSpec::Matchers.define :update_index do |type_name|
+RSpec::Matchers.define :update_index do |type_name, options = {}|
   chain(:and_reindex) do |*args|
     @reindex ||= {}
     @reindex.merge!(extract_documents(*args))
@@ -9,9 +9,15 @@ RSpec::Matchers.define :update_index do |type_name|
     @delete.merge!(extract_documents(*args))
   end
 
+  chain(:only) do |*args|
+    @only = true
+  end
+
   match do |block|
     @reindex ||= {}
     @delete ||= {}
+    @missed_reindex = []
+    @missed_delete = []
 
     type = Chewy.derive_type(type_name)
     updated = []
@@ -24,7 +30,11 @@ RSpec::Matchers.define :update_index do |type_name|
       end
     end
 
-    block.call
+    if options[:atomic] == false
+      block.call
+    else
+      Chewy.atomic { block.call }
+    end
 
     @updated = updated
     @updated.each do |updated_document|
@@ -32,10 +42,14 @@ RSpec::Matchers.define :update_index do |type_name|
         if document = @reindex[body[:_id].to_s]
           document[:real_count] += 1
           document[:real_attributes].merge!(body[:data])
+        else
+          @missed_reindex.push(body[:_id].to_s) if @only
         end
       elsif body = updated_document[:delete]
         if document = @delete[body[:_id].to_s]
           document[:real_count] += 1
+        else
+          @missed_delete.push(body[:_id].to_s) if @only
         end
       end
     end
@@ -51,7 +65,7 @@ RSpec::Matchers.define :update_index do |type_name|
         (document[:expected_count] && document[:expected_count] == document[:real_count])
     end
 
-    @updated.any? &&
+    @updated.any? && @missed_reindex.none? && @missed_delete.none? &&
     @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
     @delete.all? { |_, document| document[:match_count] }
   end
@@ -61,6 +75,9 @@ RSpec::Matchers.define :update_index do |type_name|
 
     if @updated.none?
       output << "Expected index `#{type_name}` to be updated, but it was not\n"
+    else
+      output << "Expected index `#{type_name}` to update documents #{@reindex.keys} only, but #{@missed_reindex} was updated also\n" if @missed_reindex.any?
+      output << "Expected index `#{type_name}` to delete documents #{@delete.keys} only, but #{@missed_delete} was deleted also\n" if @missed_delete.any?
     end
 
     output << @reindex.each.with_object('') do |(id, document), output|

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

@@ -1,11 +1,12 @@
+require 'chewy/type/adapter/base'
+
 module Chewy
   module Type
     module Adapter
-      class ActiveRecord
-        attr_reader :model, :scope, :options
-
-        def initialize subject, options = {}
-          @options = options
+      class ActiveRecord < Base
+        def initialize *args
+          @options = args.extract_options!
+          subject = args.first
           if subject.is_a?(::ActiveRecord::Relation)
             @model = subject.klass
             @scope = subject
@@ -21,6 +22,78 @@ module Chewy
         def type_name
           @type_name ||= (options[:name].presence || model.model_name).to_s.underscore
         end
+
+        def import *args, &block
+          import_options = args.extract_options!
+          import_options[:batch_size] ||= BATCH_SIZE
+          collection = args.none? ? model_all :
+            (args.one? && args.first.is_a?(::ActiveRecord::Relation) ? args.first : args.flatten)
+          if collection.is_a?(::ActiveRecord::Relation)
+            result = false
+            merged_scope(collection).find_in_batches(import_options.slice(:batch_size)) do |group|
+              result = block.call grouped_objects(group)
+            end
+            result
+          else
+            if collection.all? { |object| object.respond_to?(:id) }
+              collection.in_groups_of(import_options[:batch_size], false).all? do |group|
+                block.call grouped_objects(group)
+              end
+            else
+              import_ids(collection, import_options, &block)
+            end
+          end
+        end
+
+        def load *args
+          load_options = args.extract_options!
+          objects = args.flatten
+
+          scope = model.where(id: objects.map(&:id))
+          loaded_objects = if load_options[:scope].is_a?(Proc)
+            scope.instance_eval(&load_options[:scope])
+          elsif load_options[:scope].is_a?(::ActiveRecord::Relation)
+            scope.merge(load_options[:scope])
+          else
+            scope
+          end.index_by { |object| object.id.to_s }
+
+          objects.map { |object| loaded_objects[object.id.to_s] }
+        end
+
+      private
+
+        attr_reader :model, :scope, :options
+
+        def import_ids(ids, import_options = {}, &block)
+          ids = ids.map(&:to_i).uniq
+
+          indexed = false
+          merged_scope(model.where(id: ids)).find_in_batches(import_options.slice(:batch_size)) do |objects|
+            ids -= objects.map(&:id)
+            indexed = block.call index: objects
+          end
+
+          deleted = ids.in_groups_of(import_options[:batch_size], false).all? do |group|
+            block.call(delete: group)
+          end
+
+          indexed && deleted
+        end
+
+        def grouped_objects(objects)
+          objects.group_by do |object|
+            object.destroyed? ? :delete : :index
+          end
+        end
+
+        def merged_scope(target)
+          scope ? scope.clone.merge(target) : target
+        end
+
+        def model_all
+          ::ActiveRecord::VERSION::MAJOR < 4 ? model.scoped : model.all
+        end
       end
     end
   end

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

@@ -0,0 +1,46 @@
+module Chewy
+  module Type
+    module Adapter
+      # Basic adapter class. Contains interface, need to implement to add any classes support
+      class Base
+        BATCH_SIZE = 1000
+
+        # Camelcased name, used as type class constant name.
+        # For returned value 'Product' will be generated class name `ProductsIndex::Product`
+        #
+        def name
+          raise NotImplementedError
+        end
+
+        # Underscored type name, user for elasticsearch type creation
+        # and for type class access with ProductsIndex.type_hash hash or method.
+        # `ProductsIndex.type_hash['product']` or `ProductsIndex.product`
+        #
+        def type_name
+          raise NotImplementedError
+        end
+
+        # Splits passed objects to groups according to `:batch_size` options.
+        # For every group crates hash with action keys. Example:
+        #
+        #   { delete: [object1, object2], index: [object3, object4, object5] }
+        #
+        # Returns true id all the block call returns true and false otherwise
+        #
+        def import *args, &block
+          raise NotImplementedError
+        end
+
+        # Returns array of loaded objects for passed objects array. If some object
+        # was not loaded, it returns `nil` in the place of this object
+        #
+        #   load(double(id: 1), double(id: 2), double(id: 3)) #=>
+        #     # [<Product id: 1>, nil, <Product id: 3>], assuming, #2 was not found
+        #
+        def load *args
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,52 @@
+require 'chewy/type/adapter/base'
+
 module Chewy
   module Type
     module Adapter
-      class Object
-        attr_reader :subject, :options
-
-        def initialize subject, options = {}
-          @options = options
-          @subject = subject
+      class Object < Base
+        def initialize *args
+          @options = args.extract_options!
+          @target = args.first
         end
 
         def name
-          @name ||= subject.to_s.camelize
+          @name ||= (options[:name] || target).to_s.camelize
         end
 
         def type_name
-          @type_name ||= subject.to_s.underscore
+          @type_name ||= (options[:name] || target).to_s.underscore
+        end
+
+        def import *args, &block
+          import_options = args.extract_options!
+          batch_size = import_options.delete(:batch_size) || BATCH_SIZE
+          objects = args.flatten
+
+          objects.in_groups_of(batch_size, false).all? do |group|
+            action_groups = group.group_by do |object|
+              raise "Object is not a `#{target}`" if class_target? && !object.is_a?(target)
+              object.respond_to?(:destroyed?) && object.destroyed? ? :delete : :index
+            end
+            block.call action_groups
+          end
+        end
+
+        def load *args
+          load_options = args.extract_options!
+          objects = args.flatten
+          if class_target?
+            objects.map { |object| target.wrap(object) }
+          else
+            objects
+          end
+        end
+
+      private
+
+        attr_reader :target, :options
+
+        def class_target?
+          @class_target ||= @target.is_a?(Class)
         end
       end
     end

data/lib/chewy/type/base.rb

@@ -25,7 +25,7 @@ module Chewy
         raise NotImplementedError
       end
 
-      def self.type_name(suggest = nil)
+      def self.type_name
         adapter.type_name
       end
 

data/lib/chewy/type/import.rb

@@ -3,62 +3,36 @@ module Chewy
     module Import
       extend ActiveSupport::Concern
 
-      included do
-      end
-
       module ClassMethods
         def bulk(options = {})
           client.bulk options.merge(index: index.index_name, type: type_name)
         end
 
         def import(*args)
-          options = args.extract_options!
-          collection = args.first || adapter.model.all
-
-          if collection.is_a? ::ActiveRecord::Relation
-            scoped_relation(collection)
-              .find_in_batches(options.slice(:batch_size)) { |objects| import_objects objects }
-          else
-            collection = Array.wrap(collection)
-            if collection.all? { |entity| entity.respond_to?(:id) }
-              import_objects collection
-            else
-              import_ids collection, options
+          import_options = args.extract_options!
+          bulk_options = import_options.extract!(:refresh).reverse_merge!(refresh: true)
+          identify = {_index: index.index_name, _type: type_name}
+
+          adapter.import(*args, import_options) do |action_objects|
+            payload = {type: self}
+            payload.merge! import: Hash[action_objects.map { |action, objects| [action, objects.count] }]
+
+            ActiveSupport::Notifications.instrument 'import_objects.chewy', payload do
+              body = action_objects.each.with_object([]) do |(action, objects), result|
+                result.concat(if action == :delete
+                  objects.map { |object| { action => identify.merge(_id: object.respond_to?(:id) ? object.id : object) } }
+                else
+                  objects.map { |object| { action => identify.merge(_id: object.id, data: object_data(object)) } }
+                end)
+              end
+              body.any? ? !!bulk(bulk_options.merge(body: body)) : true
             end
           end
         end
 
       private
 
-        def scoped_relation(relation)
-          adapter.scope ? relation.merge(adapter.scope) : relation
-        end
-
-        def import_ids(ids, options = {})
-          ids = ids.map(&:to_i).uniq
-          scoped_relation(adapter.model.where(id: ids))
-            .find_in_batches(options.slice(:batch_size)) do |objects|
-              ids -= objects.map(&:id)
-              import_objects objects
-            end
-
-          body = ids.map { |id| {delete: {_index: index.index_name, _type: type_name, _id: id}} }
-          bulk refresh: true, body: body if body.any?
-        end
-
-        def import_objects(objects)
-          body = objects.map do |object|
-            identify = {_index: index.index_name, _type: type_name, _id: object.id}
-            if object.respond_to?(:destroyed?) && object.destroyed?
-              {delete: identify}
-            else
-              {index: identify.merge!(data: object_to_data(object))}
-            end
-          end
-          bulk refresh: true, body: body if body.any?
-        end
-
-        def object_to_data(object)
+        def object_data(object)
           (self.root_object ||= build_root).compose(object)[type_name.to_sym]
         end
       end