chewy 0.0.1

data/lib/chewy/query/loading.rb

@@ -0,0 +1,27 @@
+module Chewy
+  class Query
+    module Loading
+      extend ActiveSupport::Concern
+
+      def load(options = {})
+        ::Kaminari.paginate_array(_load_objects(options),
+          limit: limit_value, offset: offset_value, total_count: total_count)
+      end
+
+    private
+
+      def _load_objects(options)
+        loaded_objects = Hash[_results.group_by(&:class).map do |type, objects|
+          model = type.adapter.model
+          scope = model.where(id: objects.map(&:id))
+          additional_scope = options[:scopes][type.type_name.to_sym] if options[:scopes]
+          scope = scope.instance_eval(&additional_scope) if additional_scope
+
+          [type, scope.index_by(&:id)]
+        end]
+
+        _results.map { |result| loaded_objects[result.class][result.id.to_i] }.compact
+      end
+    end
+  end
+end

data/lib/chewy/query/pagination.rb

@@ -0,0 +1,39 @@
+require 'kaminari'
+
+module Chewy
+  class Query
+    module Pagination
+      extend ActiveSupport::Concern
+
+      included do
+        include Kaminari::PageScopeMethods
+
+        delegate :default_per_page, :max_per_page, :max_pages, to: :_kaminari_config
+
+        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 total_count
+        _response['hits']['total']
+      end
+
+      def limit_value
+        (criteria.search[:size].presence || default_per_page).to_i
+      end
+
+      def offset_value
+        criteria.search[:from].to_i
+      end
+
+    private
+
+      def _kaminari_config
+        Kaminari.config
+      end
+    end
+  end
+end

data/lib/chewy/rspec.rb

@@ -0,0 +1 @@
+require 'chewy/rspec/update_index'

data/lib/chewy/rspec/update_index.rb

@@ -0,0 +1,121 @@
+RSpec::Matchers.define :update_index do |type_name|
+  chain(:and_reindex) do |*args|
+    @reindex ||= {}
+    @reindex.merge!(extract_documents(*args))
+  end
+
+  chain(:and_delete) do |*args|
+    @delete ||= {}
+    @delete.merge!(extract_documents(*args))
+  end
+
+  match do |block|
+    @reindex ||= {}
+    @delete ||= {}
+
+    type = Chewy.derive_type(type_name)
+    updated = []
+    type.stub(:bulk) do |options|
+      updated += options[:body].map do |updated_document|
+        updated_document = updated_document.symbolize_keys
+        body = updated_document[:index] || updated_document[:delete]
+        body[:data] = body[:data].symbolize_keys if body[:data]
+        updated_document
+      end
+    end
+
+    block.call
+
+    @updated = updated
+    @updated.each do |updated_document|
+      if body = updated_document[:index]
+        if document = @reindex[body[:_id].to_s]
+          document[:real_count] += 1
+          document[:real_attributes].merge!(body[:data])
+        end
+      elsif body = updated_document[:delete]
+        if document = @delete[body[:_id].to_s]
+          document[:real_count] += 1
+        end
+      end
+    end
+
+    @reindex.each do |_, document|
+      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+        (document[:expected_count] && document[:expected_count] == document[:real_count])
+      document[:match_attributes] = document[:expected_attributes].blank? ||
+        document[:real_attributes].slice(*document[:expected_attributes].keys) == document[:expected_attributes]
+    end
+    @delete.each do |_, document|
+      document[:match_count] = (!document[:expected_count] && document[:real_count] > 0) ||
+        (document[:expected_count] && document[:expected_count] == document[:real_count])
+    end
+
+    @updated.any? &&
+    @reindex.all? { |_, document| document[:match_count] && document[:match_attributes] } &&
+    @delete.all? { |_, document| document[:match_count] }
+  end
+
+  failure_message_for_should do
+    output = ''
+
+    if @updated.none?
+      output << "Expected index `#{type_name}` to be updated, but it was not\n"
+    end
+
+    output << @reindex.each.with_object('') do |(id, document), output|
+      unless document[:match_count] && document[:match_attributes]
+        output << "Expected document with id `#{id}` to be reindexed"
+        if document[:real_count] > 0
+          output << "\n   #{document[:expected_count]} times, but was reindexed #{document[:real_count]} times" if document[:expected_count] && !document[:match_count]
+          output << "\n   with #{document[:expected_attributes]}, but it was reindexed with #{document[:real_attributes]}" if document[:expected_attributes].present? && !document[:match_attributes]
+        else
+          output << ", but it was not"
+        end
+        output << "\n"
+      end
+    end
+
+    output << @delete.each.with_object('') do |(id, document), output|
+      unless document[:match_count]
+        output << "Expected document with id `#{id}` to be deleted"
+        if document[:real_count] > 0 && document[:expected_count] && !document[:match_count]
+          output << "\n   #{document[:expected_count]} times, but was deleted #{document[:real_count]} times"
+        else
+          output << ", but it was not"
+        end
+        output << "\n"
+      end
+    end
+
+    output
+  end
+
+  failure_message_for_should_not do
+    if @updated.any?
+      "Expected index `#{type_name}` not to be updated, but it was with #{
+        @updated.map(&:values).flatten.group_by { |documents| documents[:_id] }.map do |id, documents|
+          "\n  document id `#{id}` (#{documents.count} times)"
+        end.join
+      }\n"
+    end
+  end
+
+  def extract_documents *args
+    options = args.extract_options!
+
+    expected_count = options[:times] || options[:count]
+    expected_attributes = (options[:with] || options[:attributes] || {}).symbolize_keys!
+
+    Hash[args.flatten.map do |document|
+      id = document.respond_to?(:id) ? document.id.to_s : document.to_s
+      [id, {
+        document: document,
+        expected_count: expected_count,
+        expected_attributes: expected_attributes,
+        real_count: 0,
+        real_attributes: {}
+      }]
+    end]
+  end
+end

data/lib/chewy/type.rb

@@ -0,0 +1,22 @@
+require 'chewy/type/base'
+
+module Chewy
+  module Type
+    def self.new(index, target, options = {}, &block)
+      type = Class.new(Chewy::Type::Base)
+
+      adapter = if (target.is_a?(Class) && target < ActiveRecord::Base) || target.is_a?(::ActiveRecord::Relation)
+        Chewy::Type::Adapter::ActiveRecord.new(target, options)
+      else
+        Chewy::Type::Adapter::Object.new(target)
+      end
+
+      index.const_set(adapter.name, type)
+      type.send(:define_singleton_method, :index) { index }
+      type.send(:define_singleton_method, :adapter) { adapter }
+
+      type.class_eval &block if block
+      type
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Chewy
+  module Type
+    module Adapter
+      class ActiveRecord
+        attr_reader :model, :scope, :options
+
+        def initialize subject, options = {}
+          @options = options
+          if subject.is_a?(::ActiveRecord::Relation)
+            @model = subject.klass
+            @scope = subject
+          else
+            @model = subject
+          end
+        end
+
+        def name
+          @name ||= options[:name].present? ? options[:name].to_s.camelize : model.model_name.to_s
+        end
+
+        def type_name
+          @type_name ||= (options[:name].presence || model.model_name).to_s.underscore
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Chewy
+  module Type
+    module Adapter
+      class Object
+        attr_reader :subject, :options
+
+        def initialize subject, options = {}
+          @options = options
+          @subject = subject
+        end
+
+        def name
+          @name ||= subject.to_s.camelize
+        end
+
+        def type_name
+          @type_name ||= subject.to_s.underscore
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/base.rb

@@ -0,0 +1,41 @@
+require 'chewy/index/search'
+require 'chewy/type/mapping'
+require 'chewy/type/wrapper'
+require 'chewy/type/observe'
+require 'chewy/type/import'
+require 'chewy/type/adapter/object'
+require 'chewy/type/adapter/active_record'
+
+module Chewy
+  module Type
+    class Base
+      include Chewy::Index::Search
+      include Mapping
+      include Wrapper
+      include Observe
+      include Import
+
+      singleton_class.delegate :client, to: :index
+
+      def self.index
+        raise NotImplementedError
+      end
+
+      def self.adapter
+        raise NotImplementedError
+      end
+
+      def self.type_name(suggest = nil)
+        adapter.type_name
+      end
+
+      def self.search_index
+        index
+      end
+
+      def self.search_type
+        type_name
+      end
+    end
+  end
+end

data/lib/chewy/type/import.rb

@@ -0,0 +1,67 @@
+module Chewy
+  module Type
+    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
+            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)
+          (self.root_object ||= build_root).compose(object)[type_name.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/mapping.rb

@@ -0,0 +1,50 @@
+module Chewy
+  module Type
+    module Mapping
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :root_object, instance_reader: false, instance_writer: false
+      end
+
+      module ClassMethods
+        def root(options = {}, &block)
+          raise "Root is already defined" if self.root_object
+          build_root(options, &block)
+        end
+
+        def field(*args, &block)
+          options = args.extract_options!
+          build_root unless self.root_object
+
+          if args.size > 1
+            args.map { |name| field(name, options) }
+          else
+            expand_nested(Chewy::Fields::Default.new(args.first, options), &block)
+          end
+        end
+
+        def mappings_hash
+          root_object ? root_object.mappings_hash : {}
+        end
+
+      private
+
+        def expand_nested(field, &block)
+          @_current_field.nested(field) if @_current_field
+          if block
+            previous_field, @_current_field = @_current_field, field
+            block.call
+            @_current_field = previous_field
+          end
+        end
+
+        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
+        end
+      end
+    end
+  end
+end

data/lib/chewy/type/observe.rb

@@ -0,0 +1,37 @@
+module Chewy
+  module Type
+    module Observe
+      extend ActiveSupport::Concern
+
+      module ActiveRecordMethods
+        def update_elasticsearch(type_name, &block)
+          update = Proc.new do
+            Chewy.derive_type(type_name).update_index(instance_eval(&block))
+          end
+
+          after_save &update
+          after_destroy &update
+        end
+      end
+
+      module ClassMethods
+        def update_index(objects)
+          if Chewy.observing_enabled
+            if Chewy.atomic?
+              ids = if objects.is_a?(::ActiveRecord::Relation)
+                objects.pluck(:id)
+              else
+                Array.wrap(objects).map { |object| object.respond_to?(:id) ? object.id : object.to_i }
+              end
+              Chewy.atomic_stash self, ids
+            else
+              import objects
+            end if objects
+          end
+
+          true
+        end
+      end
+    end
+  end
+end