chewy 0.10.1 → 5.0.0

data/lib/chewy/type/crutch.rb

@@ -12,7 +12,7 @@ module Chewy
         def initialize(type, collection)
           @type = type
           @collection = collection
-          @type._crutches.keys.each do |name|
+          @type._crutches.each_key do |name|
             singleton_class.class_eval <<-METHOD, __FILE__, __LINE__ + 1
               def #{name}
                 @#{name} ||= @type._crutches[:#{name}].call @collection

data/lib/chewy/type/import.rb

@@ -116,16 +116,17 @@ module Chewy
         def compose(object, crutches = nil, fields: [])
           crutches ||= Chewy::Type::Crutch::Crutches.new self, [object]
 
-          if witchcraft? && build_root.children.present?
+          if witchcraft? && root.children.present?
             cauldron(fields: fields).brew(object, crutches)
           else
-            build_root.compose(object, crutches, fields: fields)
+            root.compose(object, crutches, fields: fields)
           end
         end
 
       private
 
         def import_routine(*args)
+          return if args.first.blank? && !args.first.nil?
           routine = Routine.new(self, args.extract_options!)
           routine.create_indexes!
 

data/lib/chewy/type/import/bulk_builder.rb

@@ -114,7 +114,7 @@ module Chewy
         end
 
         def type_root
-          @type_root = @type.send(:build_root)
+          @type_root ||= @type.root
         end
       end
     end

data/lib/chewy/type/import/journal_builder.rb

@@ -10,7 +10,7 @@ module Chewy
 
         def bulk_body
           Chewy::Type::Import::BulkBuilder.new(
-            Chewy::Stash::Journal,
+            Chewy::Stash::Journal::Journal,
             index: [
               entries(:index, @index),
               entries(:delete, @delete)
@@ -18,7 +18,7 @@ module Chewy
           ).bulk_body.each do |item|
             item.values.first.merge!(
               _index: Chewy::Stash::Journal.index_name,
-              _type: Chewy::Stash::Journal.type_name
+              _type: Chewy::Stash::Journal::Journal.type_name
             )
           end
         end
@@ -31,7 +31,7 @@ module Chewy
             index_name: @type.index.derivable_name,
             type_name: @type.type_name,
             action: action,
-            references: identify(objects).map(&:to_json),
+            references: identify(objects).map(&:to_json).map(&Base64.method(:encode64)),
             created_at: Time.now.utc
           }
         end

data/lib/chewy/type/import/routine.rb

@@ -13,7 +13,7 @@ module Chewy
       #   * performs the bulk request;
       #   * composes new leftovers bulk for the next iteration basing on the response errors if `update_failover` is true;
       #   * appends the rest of unfixable errors to the instance level errors array.
-      # 4. Perform the request for the last leftovers bulk if present using {#process_leftovers}.
+      # 4. Perform the request for the last leftovers bulk if present using {#extract_leftovers}.
       # 3. Return the result errors array.
       #
       # At the moment, it tries to restore only from the partial document update errors in cases
@@ -64,7 +64,7 @@ module Chewy
         # Creates the journal index and the type corresponding index if necessary.
         # @return [Object] whatever
         def create_indexes!
-          Chewy::Stash.create if @options[:journal]
+          Chewy::Stash::Journal.create if @options[:journal]
           return if Chewy.configuration[:skip_index_creation_on_import]
           @type.index.create!(@bulk_options.slice(:suffix)) unless @type.index.exists?
         end

data/lib/chewy/type/mapping.rb

@@ -17,10 +17,11 @@ module Chewy
         # definition. Use it only if you need to pass options for root
         # object mapping, such as `date_detection` or `dynamic_date_formats`
         #
+        # @example
         #   class UsersIndex < Chewy::Index
         #     define_type User do
         #       # root object defined implicitly and optionless for current type
-        #       field :full_name, type: 'string'
+        #       field :full_name, type: 'keyword'
         #     end
         #   end
         #
@@ -28,32 +29,37 @@ module Chewy
         #     define_type Car do
         #       # explicit root definition with additional options
         #       root dynamic_date_formats: ['yyyy-MM-dd'] do
-        #         field :model_name, type: 'string'
+        #         field :model_name, type: 'keyword'
         #       end
         #     end
         #   end
         #
-        def root(options = {}, &block)
-          raise 'Root is already defined' if root_object
-          build_root(options, &block)
+        def root(**options)
+          self.root_object ||= Chewy::Fields::Root.new(type_name, Chewy.default_root_options.merge(options))
+          root_object.update_options!(options)
+          yield if block_given?
+          root_object
         end
 
         # Defines mapping field for current type
         #
+        # @example
         #   class UsersIndex < Chewy::Index
         #     define_type User do
         #       # passing all the options to field definition:
-        #       field :full_name, type: 'string', analyzer: 'special'
+        #       field :full_name, analyzer: 'special'
         #     end
         #   end
         #
         # The `type` is optional and defaults to `string` if not defined:
         #
+        # @example
         #   field :full_name
         #
         # Also, multiple fields might be defined with one call and
         # with the same options:
         #
+        # @example
         #   field :first_name, :last_name, analyzer: 'special'
         #
         # The only special option in the field definition
@@ -61,31 +67,35 @@ module Chewy
         # method will be called for the indexed object. Also
         # `:value` might be a proc or indexed object method name:
         #
+        # @example
         #   class User < ActiveRecord::Base
         #     def user_full_name
         #       [first_name, last_name].join(' ')
         #     end
         #   end
         #
-        #   field :full_name, type: 'string', value: :user_full_name
+        #   field :full_name, type: 'keyword', value: :user_full_name
         #
         # The proc evaluates inside the indexed object context if
         # its arity is 0 and in present contexts if there is an argument:
         #
-        #   field :full_name, type: 'string', value: -> { [first_name, last_name].join(' ') }
+        # @example
+        #   field :full_name, type: 'keyword', value: -> { [first_name, last_name].join(' ') }
         #
         #   separator = ' '
-        #   field :full_name, type: 'string', value: ->(user) { [user.first_name, user.last_name].join(separator) }
+        #   field :full_name, type: 'keyword', value: ->(user) { [user.first_name, user.last_name].join(separator) }
         #
         # If array was returned as value - it will be put in index as well.
         #
-        #   field :tags, type: 'string', value: -> { tags.map(&:name) }
+        # @example
+        #   field :tags, type: 'keyword', value: -> { tags.map(&:name) }
         #
         # Fields supports nesting in case of `object` field type. If
         # `user.quiz` will return an array of objects, then result index content
         # will be an array of hashes, if `user.quiz` is not a collection association
         # then just values hash will be put in the index.
         #
+        # @example
         #   field :quiz do
         #     field :question, :answer
         #     field :score, type: 'integer'
@@ -93,6 +103,7 @@ module Chewy
         #
         # Nested fields are composed from nested objects:
         #
+        # @example
         #   field :name, value: -> { name_translations } do
         #     field :ru, value: ->(name) { name['ru'] }
         #     field :en, value: ->(name) { name['en'] }
@@ -101,20 +112,19 @@ module Chewy
         # Of course it is possible to define object fields contents dynamically
         # but make sure evaluation proc returns hash:
         #
+        # @example
         #   field :name, type: 'object', value: -> { name_translations }
         #
         # The special case is multi_field. If type options and block are
         # both present field is treated as a multi-field. In that case field
         # composition changes satisfy elasticsearch rules:
         #
-        #   field :full_name, type: 'string', analyzer: 'name', value: ->{ full_name.try(:strip) } do
+        # @example
+        #   field :full_name, type: 'text', analyzer: 'name', value: ->{ full_name.try(:strip) } do
         #     field :sorted, analyzer: 'sorted'
         #   end
         #
-        def field(*args, &block)
-          options = args.extract_options!
-          build_root
-
+        def field(*args, **options, &block)
           if args.size > 1
             args.map { |name| field(name, options) }
           else
@@ -124,9 +134,9 @@ module Chewy
 
         # Defines an aggregation that can be bound to a query or filter
         #
-        #   Suppose that a user has posts and each post has ratings
-        #   avg_post_rating is the mean of all ratings
-        #
+        # @example
+        #   # Suppose that a user has posts and each post has ratings
+        #   # avg_post_rating is the mean of all ratings
         #   class UsersIndex < Chewy::Index
         #     define_type User do
         #       field :posts do
@@ -139,72 +149,68 @@ module Chewy
         #     end
         #   end
         def agg(name, &block)
-          build_root
           self._agg_defs = _agg_defs.merge(name => block)
         end
         alias_method :aggregation, :agg
 
         # Defines dynamic template in mapping root objects
         #
+        # @example
         #   class CarsIndex < Chewy::Index
         #     define_type Car do
-        #       template 'model.*', type: 'string', analyzer: 'special'
+        #       template 'model.*', type: 'text', analyzer: 'special'
         #       field 'model', type: 'object' # here we can put { de: 'Der Mercedes', en: 'Mercedes' }
         #                                     # and template will be applyed to this field
         #     end
         #   end
         #
         # Name for each template is generated with the following
-        # rule: "template_#{dynamic_templates.size + 1}".
+        # rule: `template_#!{dynamic_templates.size + 1}`.
         #
+        # @example Templates
         #   template 'tit*', mapping_hash
         #   template 'title.*', mapping_hash # dot in template causes "path_match" using
         #   template /tit.+/, mapping_hash # using "match_pattern": "regexp"
         #   template /title\..+/, mapping_hash # "\." - escaped dot causes "path_match" using
-        #   template /tit.+/, 'string', mapping_hash # "match_mapping_type" as the optionsl second argument
+        #   template /tit.+/, type: 'text', mapping_hash # "match_mapping_type" as the optionsl second argument
         #   template template42: {match: 'hello*', mapping: {type: 'object'}} # or even pass a template as is
         #
         def template(*args)
-          build_root.dynamic_template(*args)
+          root.dynamic_template(*args)
         end
         alias_method :dynamic_template, :template
 
         # Returns compiled mappings hash for current type
         #
         def mappings_hash
-          root_object ? root_object.mappings_hash : {}
+          root.mappings_hash[type_name.to_sym].present? ? root.mappings_hash : {}
         end
 
         # Check whether the type has outdated_sync_field defined with a simple value.
         #
         # @return [true, false]
         def supports_outdated_sync?
-          updated_at_field = root_object.child_hash[outdated_sync_field] if root_object && outdated_sync_field
+          updated_at_field = root.child_hash[outdated_sync_field] if outdated_sync_field
           !!updated_at_field && updated_at_field.value.nil?
         end
 
       private
 
-        def expand_nested(field, &block)
+        def expand_nested(field)
+          @_current_field ||= root
+
           if @_current_field
             field.parent = @_current_field
             @_current_field.children.push(field)
           end
 
-          return unless block
+          return unless block_given?
 
           previous_field = @_current_field
           @_current_field = field
           yield
           @_current_field = previous_field
         end
-
-        def build_root(options = {}, &block)
-          return root_object if root_object
-          self.root_object = Chewy::Fields::Root.new(type_name, Chewy.default_root_options.merge(options))
-          expand_nested(root_object, &block)
-          @_current_field = root_object
-        end
       end
     end
   end

data/lib/chewy/type/observe.rb

@@ -9,14 +9,6 @@ module Chewy
           method = args.first
 
           proc 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)
               if type_name.arity.zero?
                 instance_exec(&type_name)
@@ -27,7 +19,19 @@ module Chewy
               type_name
             end
 
-            Chewy.derive_type(reference).update_index(backreference, options)
+            type = Chewy.derive_type(reference)
+
+            next if Chewy.strategy.current.name == :bypass
+
+            backreference = if method && method.to_s == 'self'
+              self
+            elsif method
+              send(method)
+            else
+              instance_eval(&block)
+            end
+
+            type.update_index(backreference, options)
           end
         end
 

data/lib/chewy/type/syncer.rb

@@ -34,7 +34,7 @@ module Chewy
           next unless source_data_hash[id]
 
           outdated = if outdated_sync_field_type == 'date'
-            !Chewy::Type::Syncer.dates_equal(typecast_date(source_data_hash[id]), DateTime.iso8601(index_sync_value))
+            !Chewy::Type::Syncer.dates_equal(typecast_date(source_data_hash[id]), Time.iso8601(index_sync_value))
           else
             source_data_hash[id] != index_sync_value
           end
@@ -57,7 +57,7 @@ module Chewy
         if string.is_a?(String) && (match = ISO_DATETIME.match(string))
           microsec = (match[7].to_r * 1_000_000).to_i
           date = "#{match[1]}-#{match[2]}-#{match[3]}T#{match[4]}:#{match[5]}:#{match[6]}.#{format('%06d', microsec)}+00:00"
-          DateTime.iso8601(date)
+          Time.iso8601(date)
         else
           string
         end

data/lib/chewy/type/witchcraft.rb

@@ -58,9 +58,9 @@ module Chewy
       private
 
         def alicorn
-          @alicorn ||= class_eval <<-RUBY
+          @alicorn ||= class_eval <<-RUBY, __FILE__, __LINE__ + 1
             -> (locals, object0, crutches) do
-              #{composed_values(@type.root_object, 0)}
+              #{composed_values(@type.root, 0)}
             end
           RUBY
         end

data/lib/chewy/type/wrapper.rb

@@ -70,11 +70,11 @@ module Chewy
       end
 
       def attribute_defined?(attribute)
-        self.class.root_object && self.class.root_object.children.find { |a| a.name.to_s == attribute }.present?
+        self.class.root && self.class.root.children.find { |a| a.name.to_s == attribute }.present?
       end
 
       def highlight(attribute)
-        _data['highlight'][attribute].first
+        _data['highlight'][attribute].first if highlight?(attribute)
       end
 
       def highlight?(attribute)

data/lib/chewy/version.rb

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

data/lib/sequel/plugins/chewy_observe.rb

@@ -36,40 +36,25 @@ module Sequel
           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
+          set_callback(:save, callback_options, &update_proc)
+          set_callback(:destroy, callback_options, &update_proc)
         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
+            db.after_commit {} if Chewy.use_after_commit_callbacks
           end
         end
 
         def after_destroy
           run_callbacks(:destroy) do
             super
+            db.after_commit {} if Chewy.use_after_commit_callbacks
           end
         end
       end

data/spec/chewy/config_spec.rb

@@ -137,5 +137,21 @@ describe Chewy::Config do
     specify do
       expect(subject.configuration).to include(indices_path: 'app/custom_indices_path')
     end
+
+    context 'when Rails::VERSION constant is defined' do
+      it 'looks for configuration in "config/chewy.yml"' do
+        module Rails
+          VERSION = '5.1.0'.freeze
+
+          def self.root
+            Pathname.new(__dir__)
+          end
+        end
+
+        expect(File).to receive(:exist?)
+          .with(Pathname.new(__dir__).join('config', 'chewy.yml'))
+        subject.configuration
+      end
+    end
   end
 end