chewy 8.2.1 → 8.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec704929088d1e1f785d46b74dd62197c2a173ff5b405d500ab4068b6025d407
-  data.tar.gz: ed17897341f8c43713c41d6e0b22a71afa13899a3c553baf6d034072ad40712a
+  metadata.gz: 34d773f10bf67d60eca51ff91a6d668186eea74515bb5b31a5fd5ce814dac3c7
+  data.tar.gz: 334c6e92185369170b9f4d534029b69c218bb3c0cabfe6e4c11fd79268c19587
 SHA512:
-  metadata.gz: e957fc1353e97b268ead1e99ac9665eac7bd8d0d4eceaff205c07763c7690f8ea173844aeac1be7a9f1af6138b875f49508ed68a21d92814660916aa057566ad
-  data.tar.gz: d3ece465fadfae3486f28303eadd1919e5b760e797e41ab231d797363c9ed5143fa616b270f342172ef63bd128780f21ca54f1675d6507749ae5c7aca1278025
+  metadata.gz: 24bde735bcfc4f1bfec8b146cdcc5024d049e1405ccfbbae5e6f57f53a89aa9a6951063b00251a2f87fafac3632e1640fddc64038c7337e9147a0b9d6740f984
+  data.tar.gz: d2d84b1d2d3b07bde52699dfc54ed3b9ac8b9b71c5d79ca204851abab06bf53a41f0591ded6cdab59be5bf87522374dc10ff01d180891bcf81d73d33b009e180

data/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## master (unreleased
+## master (unreleased)
 
 ### New Features
 
@@ -8,6 +8,20 @@
 
 ### Changes
 
+## 8.3.0 (2026-06-03)
+
+### New Features
+
+* New compiled compose path is now the default for every index. Chewy generates one `__chewy_compose__` method per index from the field tree on first import and reuses it for every object, replacing the iterative `Fields::Root#compose` loop. Typical document composition is 3-4× faster than the iterative path and matches `witchcraft!` performance without any extra dependencies. `update_fields:` partial imports are also covered via per-fields-set memoized methods.
+
+### Bug Fixes
+
+### Changes
+
+* **Deprecation:** `Chewy::Index.witchcraft!` is deprecated and will be removed in a future major release. It now prints a deprecation warning and is no longer required for fast composition — the compiled compose path described above is the default and delivers equivalent throughput without `method_source` / `parser` / `prism` / `unparser`. The `parser` / `prism` / `unparser` requires are now lazy and only loaded when an index actually calls `witchcraft!`, eliminating ~24 MiB of boot-time allocations and ~1 MiB of retained memory for apps that don't use it ([#644](https://github.com/toptal/chewy/issues/644)).
+
+* [#1028](https://github.com/toptal/chewy/pull/1028): Remove the obsolete `_type` field from mock response helpers (`Chewy::Minitest::Helpers`, `Chewy::Rspec::Helpers`), `EVERFIELDS`, and `Chewy::Index::Wrapper` accessors. Elasticsearch removed `_type` from search responses in 8.0 (ES 7 already returned only the placeholder `_doc`), so these references no longer matched real responses. Also removes the long-obsolete `_parent` entry from `EVERFIELDS`. ([@mattmenefee][])
+
 ## 8.2.1 (2026-06-01)
 
 ### New Features

data/README.md

@@ -218,7 +218,6 @@ end
     },
     "_data":{
       "_index":"users",
-      "_type":"_doc",
       "_id":"1",
       "_score":0.9808291,
       "_source":{
@@ -236,7 +235,7 @@ end
 
 - [Getting Started](docs/getting_started.md) — end-to-end tutorial building search for a media library
 - [Configuration](docs/configuration.md) — client settings, update strategies, notifications, integrations
-- [Indexing](docs/indexing.md) — index definition, field types, crutches, witchcraft, index manipulation
+- [Indexing](docs/indexing.md) — index definition, field types, crutches, compiled compose path, index manipulation
 - [Import](docs/import.md) — import options, raw import, journaling
 - [Querying](docs/querying.md) — search requests, pagination, scopes, scroll, loading
 - [Rake Tasks](docs/rake_tasks.md) — all rake tasks and parallelization

data/lib/chewy/fields/root.rb

@@ -3,10 +3,12 @@ module Chewy
     class Root < Chewy::Fields::Base
       attr_reader :dynamic_templates, :id
 
+      DEFAULT_VALUE = -> { self }
+
       def initialize(name, **options)
         super
 
-        @value ||= -> { self }
+        @value ||= DEFAULT_VALUE
         @dynamic_templates = []
       end
 

data/lib/chewy/index/compiled.rb

@@ -0,0 +1,235 @@
+module Chewy
+  class Index
+    # Compiled compose path. Default for all indexes.
+    #
+    # Generates a single `__chewy_compose__` method per index from the
+    # field tree (no Ruby source parsing of user procs). Bakes the
+    # per-field arity into the call site and inlines hash construction,
+    # removing the per-field iteration + dispatch overhead of the legacy
+    # plain compose path. Proc bodies are NOT inlined — procs are called
+    # via `.call`. In exchange there are no parser/unparser/method_source
+    # deps and no Ruby/Prism version coupling.
+    #
+    # `fields:` selection is supported: a dedicated method is generated
+    # and memoized per unique fields set.
+    #
+    # Falls back to the plain `Chewy::Fields::Root#compose` path when the
+    # field tree uses features the compiler does not handle:
+    # ignore_blank, geo_point, custom root value.
+    module Compiled
+      extend ActiveSupport::Concern
+
+      class UNSUPPORTED < StandardError
+      end
+
+      COMPILE_MUTEX = Mutex.new
+
+      module ClassMethods
+        # Returns true when this index can use the compiled path for the
+        # given compose call. Builds the per-fields method if needed.
+        def compiled_compose_available?(fields)
+          return false if witchcraft?
+          return false unless root&.children&.present?
+
+          ensure_compiled_compose_for!(fields)
+        rescue UNSUPPORTED
+          false
+        end
+
+        def compiled_compose(object, crutches, context, fields)
+          send(compiled_method_name(fields), object, crutches, context)
+        end
+
+        def compiled_procs
+          @compiled_procs ||= []
+        end
+
+        # Build (and cache) the compiled compose method for the given
+        # fields restriction. Returns true on success, false / raises on
+        # unsupported. Thread-safe: compilation under a process-wide
+        # mutex prevents two threads from interleaving appends into
+        # @compiled_procs and baking duplicate indices into class_eval'd
+        # method bodies.
+        def ensure_compiled_compose_for!(fields)
+          key = fields_key(fields)
+          built = (@compiled_compose_built ||= {})
+          return built[key] if built.key?(key)
+
+          COMPILE_MUTEX.synchronize do
+            return built[key] if built.key?(key)
+
+            method_name = compiled_method_name(fields)
+            source      = Compiler.new(self, fields: fields, method_name: method_name).build
+            class_eval(source, __FILE__, __LINE__)
+            built[key] = true
+          end
+        rescue UNSUPPORTED
+          (@compiled_compose_built ||= {})[fields_key(fields)] = false
+          raise
+        end
+
+        # Clears compiled-method cache and rebuilds-on-next-call. Hooked
+        # from `Mapping.field` so a `field` added after the first compose
+        # is picked up rather than absent from a stale generated method.
+        # Existing singleton methods remain defined (they shadow until
+        # rebuilt) but the cache flag is dropped so the next compose
+        # rebuilds and reassigns them.
+        def invalidate_compiled_compose!
+          @compiled_compose_built = nil
+          @compiled_procs = nil
+          @compiled_default_ready = false
+        end
+
+        def compiled_method_name(fields)
+          key = fields_key(fields)
+          return :__chewy_compose__ if key.empty?
+
+          :"__chewy_compose__#{key}"
+        end
+
+      private
+
+        # Distinct field sets are kept distinct by hashing the joined,
+        # sorted symbol names rather than joining with a separator that
+        # collides with `_` inside field names (e.g. [:full_name, :id]
+        # vs [:full, :name_id]). Hex-encoding the digest keeps the
+        # method name a valid Ruby identifier.
+        def fields_key(fields)
+          return ''.freeze if fields.nil? || fields.empty?
+
+          require 'digest'
+          Digest::SHA1.hexdigest(fields.map(&:to_sym).sort.join("\0"))[0, 12]
+        end
+      end
+
+      class Compiler
+        IDENTIFIER_RE = /\A[A-Za-z_][A-Za-z0-9_]*[!?=]?\z/
+
+        def initialize(index, fields: [], method_name: :__chewy_compose__)
+          @index       = index
+          @procs       = index.compiled_procs
+          @counter     = 0
+          @fields      = fields.map(&:to_sym)
+          @method_name = method_name
+        end
+
+        def build
+          check_root_value!(@index.root)
+          body = compose_children_src(@index.root, 'o0', restrict: @fields)
+          <<~RUBY
+            def self.#{@method_name}(o0, crutches, context)
+              #{body}.as_json
+            end
+          RUBY
+        end
+
+      private
+
+        def check_root_value!(root)
+          v = root.instance_variable_get(:@value)
+          return if v.equal?(Chewy::Fields::Root::DEFAULT_VALUE)
+
+          raise UNSUPPORTED, 'custom root value proc not supported by compiled path'
+        end
+
+        def compose_children_src(parent_field, obj_var, restrict: [])
+          children = parent_field.children
+          children = children.select { |f| restrict.include?(f.name) } if restrict.any?
+          # Plain Base#compose_children merges per-field hashes, so a field
+          # redeclared with the same name is silently last-wins. Match that
+          # here to avoid Ruby's "duplicate key" warning on the generated
+          # literal hash.
+          children = children.reverse.uniq(&:name).reverse
+
+          pairs = children.map do |f|
+            raise UNSUPPORTED, "field #{f.name}" if unsupported?(f)
+
+            # Use Ruby's literal-inspect for the key so names with quotes,
+            # backslashes, `#{}`, or other special characters are safely
+            # serialised — never raw-interpolated into source.
+            "#{f.name.to_s.inspect} => #{field_value_src(f, obj_var)}"
+          end
+          "{ #{pairs.join(', ')} }"
+        end
+
+        # Features the compiler refuses; caller falls back to plain.
+        # Join fields are supported via Field#value returning a proc.
+        def unsupported?(field)
+          return true if field.options.key?(:ignore_blank)
+          return true if field.options[:type].to_s == 'geo_point'
+
+          false
+        end
+
+        def field_value_src(field, parent_obj_var)
+          fetch = fetch_src(field, parent_obj_var)
+          return fetch if !field.children.present? || field.multi_field?
+
+          child_var = "o#{next_counter}"
+          raw_var   = "#{child_var}_raw"
+          children_src = compose_children_src(field, child_var)
+          <<~RUBY.chomp
+            (#{raw_var} = #{fetch}
+            if #{raw_var}.nil?
+              nil
+            elsif #{raw_var}.respond_to?(:to_ary)
+              #{raw_var}.to_ary.map { |#{child_var}| #{children_src} }
+            else
+              #{child_var} = #{raw_var}
+              #{children_src}
+            end)
+          RUBY
+        end
+
+        def fetch_src(field, obj_var)
+          v = field.value
+          if v.is_a?(Proc)
+            idx = @procs.size
+            @procs << v
+            procs_ref = "compiled_procs[#{idx}]"
+            param_count = positional_param_count(v)
+            case v.arity
+            when 0
+              "#{obj_var}.instance_exec(&#{procs_ref})"
+            else
+              # Pass only as many of (object, crutches, context) as the
+              # proc actually declares. This keeps lambdas with optional
+              # args (negative arity like `->(o, c=nil)`) from being
+              # called with too many arguments. Anything beyond context
+              # truncates to all three.
+              args = [obj_var, 'crutches', 'context'].first(param_count)
+              "#{procs_ref}.call(#{args.join(', ')})"
+            end
+          else
+            method_name = v.is_a?(Symbol) || v.is_a?(String) ? v.to_s : field.name.to_s
+            raise UNSUPPORTED, "non-identifier field accessor: #{method_name.inspect}" unless safe_identifier?(method_name)
+
+            # Mirror Base#value_by_name_proc: hash key-or-string fallback,
+            # method send otherwise.
+            "(#{obj_var}.is_a?(Hash) ? " \
+              "(#{obj_var}.key?(:#{method_name}) ? #{obj_var}[:#{method_name}] : #{obj_var}['#{method_name}']) : " \
+              "#{obj_var}.#{method_name})"
+          end
+        end
+
+        # Number of positional parameters declared by `proc`, counting
+        # required + optional. Splats and keyword args contribute one
+        # bucket each so the caller still passes all three context args.
+        def positional_param_count(proc)
+          params = proc.parameters
+          required = params.count { |type, _| %i[req opt].include?(type) }
+          has_splat = params.any? { |type, _| type == :rest }
+          has_splat ? 3 : [required, 3].min
+        end
+
+        def safe_identifier?(name)
+          IDENTIFIER_RE.match?(name.to_s)
+        end
+
+        def next_counter
+          @counter += 1
+        end
+      end
+    end
+  end
+end

data/lib/chewy/index/import.rb

@@ -127,7 +127,20 @@ module Chewy
         def compose(object, crutches = nil, fields: [], context: {})
           crutches ||= Chewy::Index::Crutch::Crutches.new self, [object], context
 
-          if witchcraft? && root.children.present?
+          # Hot path: the default-fields compiled method has already
+          # been built, so skip the per-call availability check and
+          # dispatch directly. Bulk reindexing hits this branch for
+          # every object after the first.
+          return __chewy_compose__(object, crutches, context) if fields.empty? && @compiled_default_ready
+
+          if compiled_compose_available?(fields)
+            if fields.empty?
+              @compiled_default_ready = true
+              __chewy_compose__(object, crutches, context)
+            else
+              compiled_compose(object, crutches, context, fields)
+            end
+          elsif witchcraft? && root.children.present?
             cauldron(fields: fields).brew(object, crutches, context)
           else
             root.compose(object, crutches, fields: fields, context: context)

data/lib/chewy/index/mapping.rb

@@ -122,6 +122,7 @@ module Chewy
         #   end
         #
         def field(*args, **options, &block)
+          invalidate_compiled_compose! if respond_to?(:invalidate_compiled_compose!)
           if args.size > 1
             args.map { |name| field(name, **options) }
           else

data/lib/chewy/index/witchcraft.rb

@@ -1,15 +1,3 @@
-begin
-  require 'method_source'
-  begin
-    require 'prism'
-  rescue LoadError
-    require 'parser/current'
-  end
-  require 'unparser'
-rescue LoadError
-  nil
-end
-
 module Chewy
   class Index
     module Witchcraft
@@ -19,8 +7,30 @@ module Chewy
         class_attribute :_witchcraft, instance_reader: false, instance_writer: false
       end
 
+      def self.load_dependencies!
+        return if @dependencies_loaded
+
+        require 'method_source'
+        begin
+          require 'prism'
+        rescue LoadError
+          require 'parser/current'
+        end
+        require 'unparser'
+        @dependencies_loaded = true
+      rescue LoadError
+        nil
+      end
+
       module ClassMethods
         def witchcraft!
+          warn(
+            '[DEPRECATION] Chewy::Index.witchcraft! is deprecated and will be removed in a future release. ' \
+            'The compiled compose path is now the default and delivers equivalent performance without ' \
+            "method_source/parser/unparser dependencies. Remove the `witchcraft!` call from #{name || self}.",
+            uplevel: 1
+          )
+          Witchcraft.load_dependencies!
           self._witchcraft = true
           check_requirements!
         end
@@ -172,7 +182,7 @@ module Chewy
         end
 
         def source_for(proc, nesting) # rubocop:disable Metrics/AbcSize
-          lambdas = exctract_lambdas(ast_from_proc(proc))
+          lambdas = extract_lambdas(ast_from_proc(proc))
 
           raise "No lambdas found, try to reformat your code:\n`#{proc.source}`" unless lambdas
 
@@ -208,13 +218,13 @@ module Chewy
           end
         end
 
-        def exctract_lambdas(node)
+        def extract_lambdas(node)
           return unless node.is_a?(Parser::AST::Node)
 
           if node.type == :block && node.children[0].type == :send && node.children[0].to_a == [nil, :lambda]
             [node.children[2]]
           else
-            node.children.map { |child| exctract_lambdas(child) }.flatten.compact
+            node.children.map { |child| extract_lambdas(child) }.flatten.compact
           end
         end
 

data/lib/chewy/index/wrapper.rb

@@ -39,7 +39,7 @@ module Chewy
         end
       end
 
-      %w[_id _type _index].each do |name|
+      %w[_id _index].each do |name|
         define_method name do
           _data[name]
         end

data/lib/chewy/index.rb

@@ -11,6 +11,7 @@ require 'chewy/index/settings'
 require 'chewy/index/specification'
 require 'chewy/index/syncer'
 require 'chewy/index/witchcraft'
+require 'chewy/index/compiled'
 require 'chewy/index/wrapper'
 
 module Chewy
@@ -32,6 +33,7 @@ module Chewy
     include Observe
     include Crutch
     include Witchcraft
+    include Compiled
     include Wrapper
 
     singleton_class.delegate :client, to: 'Chewy'

data/lib/chewy/minitest/helpers.rb

@@ -96,7 +96,6 @@ module Chewy
             'hits' => hits.each_with_index.map do |hit, i|
               {
                 '_index' => index.index_name,
-                '_type' => '_doc',
                 '_id' => hit[:id] || (i + 1).to_s,
                 '_score' => 3.14,
                 '_source' => hit

data/lib/chewy/rspec/helpers.rb

@@ -39,7 +39,6 @@ module Chewy
             'hits' => hits.each_with_index.map do |hit, i|
               {
                 '_index' => index.index_name,
-                '_type' => '_doc',
                 '_id' => (i + 1).to_s,
                 '_score' => 3.14,
                 '_source' => hit

data/lib/chewy/search/request.rb

@@ -18,7 +18,7 @@ module Chewy
       include Scoping
       include Scrolling
       UNDEFINED = Class.new.freeze
-      EVERFIELDS = %w[_index _type _id _parent _routing].freeze
+      EVERFIELDS = %w[_index _id _routing].freeze
       DELEGATED_METHODS = %i[
         query filter post_filter knn order reorder docvalue_fields
         track_scores track_total_hits request_cache explain version profile
@@ -952,7 +952,7 @@ module Chewy
 
       # Returns and array of values for specified fields.
       # Uses `source` to restrict the list of returned fields.
-      # Fields `_id`, `_type`, `_routing` and `_index` are also supported.
+      # Fields `_id`, `_routing` and `_index` are also supported.
       #
       # @overload pluck(field)
       #   If single field is passed - it returns and array of values.

data/lib/chewy/version.rb

@@ -1,3 +1,3 @@
 module Chewy
-  VERSION = '8.2.1'.freeze
+  VERSION = '8.3.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chewy
 version: !ruby/object:Gem::Version
-  version: 8.2.1
+  version: 8.3.0
 platform: ruby
 authors:
 - Toptal, LLC
@@ -83,6 +83,7 @@ files:
 - lib/chewy/index/adapter/object.rb
 - lib/chewy/index/adapter/orm.rb
 - lib/chewy/index/aliases.rb
+- lib/chewy/index/compiled.rb
 - lib/chewy/index/crutch.rb
 - lib/chewy/index/import.rb
 - lib/chewy/index/import/bulk_builder.rb