chewy 0.8.4 → 7.3.4

data/lib/chewy/type/import.rb

@@ -1,224 +0,0 @@
-module Chewy
-  class Type
-    module Import
-      extend ActiveSupport::Concern
-
-      BULK_OPTIONS = [:suffix, :bulk_size, :refresh, :consistency, :replication]
-
-      module ClassMethods
-        # Perform import operation for specified documents.
-        # Returns true or false depending on success.
-        #
-        #   UsersIndex::User.import                          # imports default data set
-        #   UsersIndex::User.import User.active              # imports active users
-        #   UsersIndex::User.import [1, 2, 3]                # imports users with specified ids
-        #   UsersIndex::User.import users                    # imports users collection
-        #   UsersIndex::User.import suffix: Time.now.to_i    # imports data to index with specified suffix if such is exists
-        #   UsersIndex::User.import refresh: false           # to disable index refreshing after import
-        #   UsersIndex::User.import batch_size: 300          # import batch size
-        #   UsersIndex::User.import bulk_size: 10.megabytes  # import ElasticSearch bulk size in bytes
-        #   UsersIndex::User.import consistency: :quorum     # explicit write consistency setting for the operation (one, quorum, all)
-        #   UsersIndex::User.import replication: :async      # explicitly set the replication type (sync, async)
-        #
-        # See adapters documentation for more details.
-        #
-        def import *args
-          import_options = args.extract_options!
-          import_options.reverse_merge! _default_import_options
-          bulk_options = import_options.reject { |k, _| !BULK_OPTIONS.include?(k) }.reverse_merge!(refresh: true)
-
-          index.create!(bulk_options.slice(:suffix)) unless index.exists?
-
-          ActiveSupport::Notifications.instrument 'import_objects.chewy', type: self do |payload|
-            adapter.import(*args, import_options) do |action_objects|
-              indexed_objects = build_root.parent_id && fetch_indexed_objects(action_objects.values.flatten)
-              body = bulk_body(action_objects, indexed_objects)
-
-              errors = bulk(bulk_options.merge(body: body)) if body.present?
-
-              fill_payload_import payload, action_objects
-              fill_payload_errors payload, errors if errors.present?
-              !errors.present?
-            end
-          end
-        end
-
-        # Perform import operation for specified documents.
-        # Raises Chewy::ImportFailed exception in case of import errors.
-        # Options are completely the same as for `import` method
-        # See adapters documentation for more details.
-        #
-        def import! *args
-          errors = nil
-          subscriber = ActiveSupport::Notifications.subscribe('import_objects.chewy') do |*args|
-            errors = args.last[:errors]
-          end
-          import *args
-          raise Chewy::ImportFailed.new(self, errors) if errors.present?
-          true
-        ensure
-          ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
-        end
-
-        # Wraps elasticsearch-ruby client indices bulk method.
-        # Adds `:suffix` option to bulk import to index with specified suffix.
-        def bulk options = {}
-          suffix = options.delete(:suffix)
-          bulk_size = options.delete(:bulk_size)
-          body = options.delete(:body)
-          header = { index: index.build_index_name(suffix: suffix), type: type_name }
-
-          bodies = if bulk_size
-            bulk_size -= 1.kilobyte # 1 kilobyte for request header and newlines
-            raise ArgumentError.new('Import `:bulk_size` can\'t be less then 1 kilobyte') if bulk_size <= 0
-
-            body.each_with_object(['']) do |entry, result|
-              operation, meta = entry.to_a.first
-              data = meta.delete(:data)
-              entry = [{ operation => meta }, data].compact.map(&:to_json).join("\n")
-              if entry.bytesize > bulk_size
-                raise ArgumentError.new('Import `:bulk_size` seems to be less then entry size')
-              elsif result.last.bytesize + entry.bytesize > bulk_size
-                result.push(entry)
-              else
-                result[-1] = [result[-1], entry].delete_if(&:blank?).join("\n")
-              end
-            end
-          else
-            [body]
-          end
-
-          items = bodies.map do |body|
-            result = client.bulk options.merge(header).merge(body: body)
-            result.try(:[], 'items') || []
-          end.flatten
-          Chewy.wait_for_status
-
-          extract_errors items
-        end
-
-      private
-
-        def bulk_body(action_objects, indexed_objects = nil)
-          action_objects.flat_map do |action, objects|
-            method = "#{action}_bulk_entry"
-            crutches = Chewy::Type::Crutch::Crutches.new self, objects
-            objects.flat_map { |object| send(method, object, indexed_objects, crutches) }
-          end
-        end
-
-        def delete_bulk_entry(object, indexed_objects = nil, crutches = nil)
-          entry = {}
-
-          if root_object.id
-            entry[:_id] = root_object.compose_id(object)
-          else
-            entry[:_id] = object.id if object.respond_to?(:id)
-            entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
-            entry[:_id] ||= object
-            entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
-          end
-
-          if root_object.parent_id
-            existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
-            entry.merge!(parent: existing_object[:parent]) if existing_object
-          end
-
-          [{ delete: entry }]
-        end
-
-        def index_bulk_entry(object, indexed_objects = nil, crutches = nil)
-          entry = {}
-
-          if root_object.id
-            entry[:_id] = root_object.compose_id(object)
-          else
-            entry[:_id] = object.id if object.respond_to?(:id)
-            entry[:_id] ||= object[:id] || object['id'] if object.is_a?(Hash)
-            entry[:_id] = entry[:_id].to_s if defined?(BSON) && entry[:_id].is_a?(BSON::ObjectId)
-          end
-          entry.delete(:_id) if entry[:_id].blank?
-
-          if root_object.parent_id
-            entry[:parent] = root_object.compose_parent(object)
-            existing_object = entry[:_id].present? && indexed_objects && indexed_objects[entry[:_id].to_s]
-          end
-
-          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 }]
-          else
-            [{ index: entry }]
-          end
-        end
-
-        def fill_payload_import payload, action_objects
-          imported = Hash[action_objects.map { |action, objects| [action, objects.count] }]
-          imported.each do |action, count|
-            payload[:import] ||= {}
-            payload[:import][action] ||= 0
-            payload[:import][action] += count
-          end
-        end
-
-        def fill_payload_errors payload, errors
-          errors.each do |action, errors|
-            errors.each do |error, documents|
-              payload[:errors] ||= {}
-              payload[:errors][action] ||= {}
-              payload[:errors][action][error] ||= []
-              payload[:errors][action][error] |= documents
-            end
-          end
-        end
-
-        def object_data object, crutches = nil
-          if witchcraft?
-            cauldron.brew(object, crutches)
-          else
-            build_root.compose(object, crutches)[type_name.to_sym]
-          end
-        end
-
-        def extract_errors items
-          items.each.with_object({}) do |item, memo|
-            action = item.keys.first.to_sym
-            data = item.values.first
-            if data['error']
-              (memo[action] ||= []).push(action: action, id: data['_id'], error: data['error'])
-            end
-          end.map do |action, items|
-            errors = items.group_by { |item| item[:error] }.map do |error, items|
-              {error => items.map { |item| item[:id] }}
-            end.reduce(&:merge)
-            {action => errors}
-          end.reduce(&:merge) || {}
-        end
-
-        def fetch_indexed_objects(objects)
-          ids = objects.map { |object| object.respond_to?(:id) ? object.id : object }
-          result = client.search index: index_name,
-                                 type: type_name,
-                                 fields: '_parent',
-                                 body: { filter: { ids: { values: ids } } },
-                                 search_type: 'scan',
-                                 scroll: '1m'
-
-          indexed_objects = {}
-
-          while result = client.scroll(scroll_id: result['_scroll_id'], scroll: '1m') do
-            break if result['hits']['hits'].empty?
-
-            result['hits']['hits'].map do |hit|
-              parent = hit.has_key?('_parent') ? hit['_parent'] : hit['fields']['_parent']
-              indexed_objects[hit['_id']] = { parent: parent }
-            end
-          end
-
-          indexed_objects
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type/observe.rb

@@ -1,76 +0,0 @@
-module Chewy
-  class Type
-    module Observe
-      extend ActiveSupport::Concern
-
-      module Helpers
-        def 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
-
-            reference = if type_name.is_a?(Proc)
-              type_name.arity == 0 ?
-                instance_exec(&type_name) :
-                type_name.call(self)
-            else
-              type_name
-            end
-
-            Chewy.derive_type(reference).update_index(backreference, options)
-          end
-        end
-
-        def extract_callback_options!(args)
-          options = args.extract_options!
-          options.each_key.with_object({}) { |key, hash|
-            hash[key] = options.delete(key) if [:if, :unless].include?(key)
-          }.tap {
-            args.push(options) unless options.empty?
-          }
-        end
-      end
-
-      extend Helpers
-
-      module MongoidMethods
-        def update_index(type_name, *args, &block)
-          callback_options = Observe.extract_callback_options!(args)
-          update_proc = Observe.update_proc(type_name, *args, &block)
-
-          after_save(callback_options, &update_proc)
-          after_destroy(callback_options, &update_proc)
-        end
-      end
-
-      module ActiveRecordMethods
-        def update_index(type_name, *args, &block)
-          callback_options = Observe.extract_callback_options!(args)
-          update_proc = Observe.update_proc(type_name, *args, &block)
-
-          if Chewy.use_after_commit_callbacks
-            after_commit(callback_options, &update_proc)
-          else
-            after_save(callback_options, &update_proc)
-            after_destroy(callback_options, &update_proc)
-          end
-        end
-      end
-
-      module ClassMethods
-        def update_index(objects, options = {})
-          Chewy.strategy.current.update(self, objects, options)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/chewy/type/wrapper.rb

@@ -1,53 +0,0 @@
-module Chewy
-  class Type
-    module Wrapper
-      extend ActiveSupport::Concern
-
-      attr_accessor :attributes, :_data, :_object
-
-      def initialize(attributes = {})
-        @attributes = attributes.stringify_keys
-      end
-
-      def ==(other)
-        if other.is_a?(Chewy::Type)
-          self.class == other.class && (respond_to?(:id) ? id == other.id : attributes == other.attributes)
-        elsif other.respond_to?(:id)
-          id.to_s == other.id.to_s
-        else
-          false
-        end
-      end
-
-      def method_missing(method_name, *args, &block)
-        method_name.to_s.match(/_highlight\z/) do |match|
-          return highlight(match.pre_match) if highlight?(match.pre_match)
-        end
-        return @attributes[method_name.to_s] if @attributes.key?(method_name.to_s)
-        return nil if attribute_defined?(method_name.to_s)
-        super
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        method_name.to_s.match(/_highlight\z/) { |m| highlight?(m.pre_match) } ||
-          @attributes.key?(method_name.to_s) ||
-          attribute_defined?(method_name.to_s) ||
-          super
-      end
-
-      private
-
-      def attribute_defined?(attribute)
-        self.class.root_object && self.class.root_object.children.find { |a| a.name.to_s == attribute }.present?
-      end
-
-      def highlight(attribute)
-        _data["highlight"][attribute].first
-      end
-
-      def highlight?(attribute)
-        _data.key?("highlight") && _data["highlight"].key?(attribute)
-      end
-    end
-  end
-end

data/lib/chewy/type.rb

@@ -1,89 +0,0 @@
-require 'chewy/search'
-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/witchcraft'
-require 'chewy/type/adapter/object'
-require 'chewy/type/adapter/active_record'
-require 'chewy/type/adapter/mongoid'
-require 'chewy/type/adapter/sequel'
-
-module Chewy
-  class Type
-    IMPORT_OPTIONS_KEYS = [:batch_size, :bulk_size, :refresh, :consistency, :replication]
-
-    include Search
-    include Mapping
-    include Wrapper
-    include Observe
-    include Actions
-    include Crutch
-    include Witchcraft
-    include Import
-
-    singleton_class.delegate :index_name, :client, to: :index
-
-    class_attribute :_default_import_options
-    self._default_import_options = {}
-
-    # Chewy index current type belongs to. Defined inside `Chewy.create_type`
-    #
-    def self.index
-      raise NotImplementedError
-    end
-
-    # Current type adapter. Defined inside `Chewy.create_type`, derived from
-    # `Chewy::Index.define_type` arguments.
-    #
-    def self.adapter
-      raise NotImplementedError
-    end
-
-    # Returns type name string
-    #
-    def self.type_name
-      adapter.type_name
-    end
-
-    # Returns list of public class methods defined in current type
-    #
-    def self.scopes
-      public_methods - Chewy::Type.public_methods
-    end
-
-    def self.default_import_options(params)
-      params.assert_valid_keys(IMPORT_OPTIONS_KEYS)
-      self._default_import_options = _default_import_options.merge(params)
-    end
-
-    def self.method_missing(method, *args, &block)
-      if index.scopes.include?(method)
-        define_singleton_method method do |*args, &block|
-          all.scoping { index.public_send(method, *args, &block) }
-        end
-        send(method, *args, &block)
-      else
-        super
-      end
-    end
-
-    def self.const_missing(name)
-      to_resolve = "#{self.to_s}::#{name}"
-      to_resolve[index.to_s] = ''
-
-      @__resolved_constants ||= {}
-
-      if to_resolve.empty? || @__resolved_constants[to_resolve]
-        super
-      else
-        @__resolved_constants[to_resolve] = true
-        to_resolve.constantize
-      end
-    rescue NotImplementedError
-      super
-    end
-  end
-end

data/lib/sequel/plugins/chewy_observe.rb

@@ -1,78 +0,0 @@
-require 'active_support/callbacks'
-
-module Sequel
-  module Plugins
-    # This Sequel plugin adds support for chewy's model-observing hook for
-    # updating indexes after model save or destroy.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses support the `update_index` hook (called
-    #   # before loading subclasses).
-    #   Sequel::Model.plugin :chewy_observe
-    #
-    #   # Make the Album class support the `update_index` hooks.
-    #   Album.plugin :chewy_observe
-    #
-    #   # Declare one or more `update_index` observers in model.
-    #   class Album < Sequel::Model
-    #     update_index('albums#album') { self }
-    #   end
-    #
-    module ChewyObserve
-      extend ::Chewy::Type::Observe::Helpers
-
-      def self.apply(model)
-        model.instance_eval do
-          include ActiveSupport::Callbacks
-          define_callbacks :commit, :destroy_commit, :save, :destroy
-        end
-      end
-
-      # Class level methods for Sequel::Model
-      #
-      module ClassMethods
-        def update_index(type_name, *args, &block)
-          callback_options = ChewyObserve.extract_callback_options!(args)
-          update_proc = ChewyObserve.update_proc(type_name, *args, &block)
-
-          if Chewy.use_after_commit_callbacks
-            set_callback(:commit, callback_options, &update_proc)
-            set_callback(:destroy_commit, callback_options, &update_proc)
-          else
-            set_callback(:save, callback_options, &update_proc)
-            set_callback(:destroy, callback_options, &update_proc)
-          end
-        end
-      end
-
-      # Instance level methods for Sequel::Model
-      #
-      module InstanceMethods
-        def after_commit
-          run_callbacks(:commit) do
-            super
-          end
-        end
-
-        def after_destroy_commit
-          run_callbacks(:destroy_commit) do
-            super
-          end
-        end
-
-        def after_save
-          run_callbacks(:save) do
-            super
-          end
-        end
-
-        def after_destroy
-          run_callbacks(:destroy) do
-            super
-          end
-        end
-      end
-    end
-  end
-end