ractorize 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 259d8a0f04fdab353871748575089e83199cfad7d81440d4e6f3a957366c9301
-  data.tar.gz: e05e67142fdd2c081ec6baf244df8f7dadf991437c12e7d27cc87c793c863956
+  metadata.gz: 65a392a1b2b1f65b1886a6650dd712848aa8707f4ab76617e14ba614684660cc
+  data.tar.gz: 330eca315af85099f83374687a8526a60a239f9c84e0908b7a77a33b69130722
 SHA512:
-  metadata.gz: ebd8a74f6bd6040740c5d41adb81f4caba0508ec28f1025eedb8a2feef826f5f09d764535593d464d3355bebe64941138f5789c9792223df8fe095af7384d985
-  data.tar.gz: 30b2f4d65a70d7218b5e3d76b1f6c04f3cb0c784fe8cd639d53770705caa61163c5c84ba678cd725f8f19296c1c6d985c6310ff461dbade04015522f96a8b155
+  metadata.gz: ec5f2a85e7efcc3c045051cb7a45b83900c82bbc1830deb744fed115c63acf0850067ea03e1b6a18198f19a927a6240ae09999c2fdbf9b316f924eb6fdc48557
+  data.tar.gz: c2840a3f37c61353ff66f70996043b78d997cfb969fd6946fc549aa6f572f9257d207e043fe63a388ef486ca58cd21021909b1755c5c06973cecc4d5490b6a56

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.0.4] - 2026-05-23
+
+- Prevent thunks from crossing ractor boundaries
+- Create instances of ractorized classes inside the ractor instead of moving them
+- Add support for methods that take blocks
+- Add #to_s/#inspect to RactorizedObject to help with debugging
+- Use #__send__ instead of #send to work with BasicObject
+
+## [0.0.3] - 2026-05-21
+
+- Treat ==, !=, and ! as predicates and delegate them to the ractor (as well as #equal?)
+- Don't wrap thunks in more thunks. Unwrap them in RACTOR_PROC which can help with Port#receive issues
+- Send a frozen array to the ractor to avoid dup/clone
+- Something somewhere in other projects calls Thunk#initialize_clone, so make a placeholder for it
+- Do not bother moving shareable objects to the ractor, just send them
+
 ## [0.0.2] - 2026-05-18
 
 - Make sure ractorized objects are shareable. This requires them to be unusable after closing (or joining) them.

data/src/ractorize/ractorized_class.rb

@@ -1,16 +1,14 @@
 module Ractorize
   class RactorizedClass
     class << self
-      attr_accessor :target_class
-
       def [](klass)
         ractorized_class = Class.new(RactorizedClass)
-        ractorized_class.target_class = klass
+        ractorized_class.define_singleton_method(:target_class, Ractor.shareable_proc { klass })
         ractorized_class
       end
 
       def new(...)
-        Ractorize.ractorize_object(target_class.new(...))
+        RactorizedObject.new(:class, target_class, ...)
       end
 
       def method_missing(method_name, ...)

data/src/ractorize/ractorized_object.rb

@@ -3,14 +3,37 @@ require_relative "thunk"
 
 module Ractorize
   class RactorizedObject < BasicObject
-    def initialize(outside_object)
+    def initialize(mode, *args, **opts, &block)
       @ractor = ::Ractor.new(&RACTOR_PROC)
 
-      # It doesn't seem like we have a way to move the object into the ractor via its constructor so do
-      # it with #<< instead.
-      @ractor.<<(outside_object, move: true)
+      case mode
+      when :object
+        @ractor << :object
+
+        outside_object = args.first
+
+        ::Ractorize.resolve_all_thunks(outside_object)
+
+        if ::Ractor.shareable?(outside_object)
+          @ractor << outside_object
+        else
+          @ractor.send(outside_object, move: true)
+        end
+      when :class
+        @ractor << :class
+
+        klass, *args = args
+
+        ::Ractorize.resolve_all_thunks(args)
+        ::Ractorize.resolve_all_thunks(opts)
+
+        @ractor << [klass, args.freeze, opts.dup.freeze, block].freeze
+      else
+        # :nocov:
+        ::Kernel.raise "Invalid mode #{mode}"
+        # :nocov:
+      end
 
-      # Wow, this works! Scary?
       ::Object.instance_method(:freeze).bind(self).call
     end
 
@@ -22,7 +45,7 @@ module Ractorize
       self
     end
 
-    def method_missing(method_name, *args, **opts)
+    def method_missing(method_name, *args, **opts, &block)
       if @ractor.default_port.closed?
         ::Kernel.raise ::Ractor::ClosedError,
                        "You already closed this Ractorized object! No more methods can be sent to it."
@@ -30,12 +53,50 @@ module Ractorize
 
       return_port = ::Ractor::Port.new
 
-      @ractor << [method_name, args, opts, return_port]
+      ::Ractorize.resolve_all_thunks(args)
+      ::Ractorize.resolve_all_thunks(opts)
+
+      @ractor << [method_name, args.dup.freeze, opts.dup.freeze, return_port, !!block].freeze
+
+      if block
+        stop = false
+        value = nil
+
+        until stop
+          data = return_port.receive
 
+          # Seems SimpleCov branch coverage doesn't like that we don't test the non-exhaustive
+          # pattern path, but since that's purely defensive I have no interest in testing it.
+
+          # :nocov:
+          case data
+          # :nocov:
+          in :return, value
+            stop = true
+          in :yield, [yielded_args, yielded_opts, yielded_block], block_result_port
+            # TODO: yielded_block likely won't work when actually used
+            # so we should probably instead just raise an exception
+            # TODO: handle break and also raise in the block
+            block_result = block.call(*yielded_args.freeze, **yielded_opts.freeze, &yielded_block)
+
+            block_result = block_result.__value__ while ::Ractorize::Thunk === block_result
+
+            block_result_port << [:normal, block_result].freeze
+          end
+        end
+
+        value
       # Let's assume the user would rather block on all predicate methods than
       # incorrectly get a non-truthy value (thunk is always truthy even if it evaluates as nil/false)
-      if method_name.end_with?("?")
-        return_port.receive
+      elsif method_name == :== || method_name == :! || method_name == :!= ||
+            method_name == :inspect || method_name == :to_s || method_name.end_with?("?")
+        value = return_port.receive
+
+        # :nocov:
+        ::Kernel.raise ::Ractorize::Thunk::EscapingRactorError if ::Ractorize::Thunk === value
+        # :nocov:
+
+        value
       else
         Thunk.new(return_port)
       end
@@ -53,5 +114,19 @@ module Ractorize
     def respond_to_missing?(method_name, include_all = false)
       method_missing(:respond_to?, method_name, include_all)
     end
+
+    def ==(other) = method_missing(:==, other)
+    def !=(other) = method_missing(:==, other)
+    def ! = method_missing(:!)
+    def equal?(other) = method_missing(:equal?, other)
+
+    def to_s = inspect
+
+    def inspect
+      object_id = ::Object.instance_method(:object_id).bind(self).call
+      moved_object_inspect = method_missing(:inspect)
+
+      "RactorizedObject<#{object_id}>[#{moved_object_inspect}]".freeze
+    end
   end
 end

data/src/ractorize/thunk.rb

@@ -1,13 +1,20 @@
 module Ractorize
   class Thunk < BasicObject
-    attr_accessor :__return_value_port__
+    class EscapingRactorError < ::StandardError; end
+
+    attr_accessor :__return_value_port__, :__ractor__
 
     def initialize(return_value_port)
+      self.__ractor__ = ::Ractor.current
       self.__return_value_port__ = return_value_port
     end
 
-    def method_missing(method_name, *)
-      __value__.send(method_name, *)
+    def initialize_clone(...)
+      # is this actually necessary?? Seems so?
+    end
+
+    def method_missing(...)
+      __value__.__send__(...)
     end
 
     def respond_to_missing?(method_name, include_all = false)
@@ -17,7 +24,23 @@ module Ractorize
     def __value__
       return @__value__ if defined?(@__value__)
 
-      @__value__ = __return_value_port__.receive
+      value = if ::Ractor.current == __ractor__
+                __return_value_port__.receive
+              else
+                # :nocov:
+                raise "Somehow this thunk was passed between ractors but wasn't resolved first."
+                # :nocov:
+              end
+
+      # :nocov:
+      ::Kernel.raise EscapingRactorError if ::Ractorize::Thunk === value
+      # :nocov:
+
+      @__value__ = value
+
+      ::Object.instance_method(:freeze).bind(self).call
+
+      value
     end
 
     def !

data/src/ractorize.rb

@@ -3,13 +3,64 @@ require_relative "ractorize/ractorized_object"
 require_relative "ractorize/ractorized_class"
 
 module Ractorize
+  class << self
+    def any_thunks?(structure)
+      # rubocop:disable Lint/UnreachableLoop
+      each_thunk(structure) { return true }
+      # rubocop:enable Lint/UnreachableLoop
+      false
+    end
+
+    # Unfortunately, can't read from a port that a different ractor made.
+    # Not sure why that is but we need to handle that case.
+    def resolve_all_thunks(structure)
+      each_thunk(structure, &:__value__)
+    end
+
+    def each_thunk(structure, seen = Set.new, &block)
+      return block.call(structure) if Thunk === structure
+      return if seen.include?(structure)
+
+      seen << structure
+
+      case structure
+      when Array
+        structure.each { each_thunk(it, seen, &block) }
+      when Hash
+        each_thunk(structure.keys, seen, &block)
+        each_thunk(structure.values, seen, &block)
+      when Struct
+        each_thunk(structure.values, seen, &block)
+      else
+        ivarsget = ::Object.instance_method(:instance_variables)
+        iget = ::Object.instance_method(:instance_variable_get)
+
+        ivarsget.bind(structure).call.each do |var|
+          each_thunk(iget.bind(structure).call(var), seen, &block)
+        end
+      end
+    end
+  end
+
   # Putting this in a constant so we can get test coverage on it since not sure how to get coverage
   # on something inside a ractor.
   RACTOR_PROC = proc do
-    object = receive
+    mode = receive
+
+    object = case mode
+             when :class
+               klass, args, opts, block = receive
+               klass.new(*args, **opts, &block)
+             when :object
+               receive
+             else
+               # :nocov:
+               ::Kernel.raise "Invalid mode #{mode}"
+               # :nocov:
+             end
 
     loop do
-      method_name, method_args, opts, return_port = receive
+      method_name, method_args, opts, return_port, block_given = receive
 
       case method_name
       when :__close__
@@ -17,18 +68,55 @@ module Ractorize
         close
         break
       else
-        value = object.__send__(method_name, *method_args, **opts)
+        if block_given
+          block_result_port = Ractor::Port.new
+
+          value = object.__send__(method_name, *method_args, **opts) do |*args, **opts, &b|
+            ::Ractorize.resolve_all_thunks(args)
+            ::Ractorize.resolve_all_thunks(opts)
+
+            return_port << [:yield, [args.dup.freeze, opts.dup.freeze, b].freeze, block_result_port].freeze
 
-        return_port << value
+            outcome_type, return_value = block_result_port.receive
+
+            case outcome_type
+            when :normal
+              return_value
+            when :break
+              break return_value
+            else
+              # :nocov:
+              ::Kernel.raise "Not sure how to handle outcome_type #{outcome_type}"
+              # :nocov:
+            end
+          end
+
+          return_port << [:return, value].freeze
+        else
+          value = object.__send__(method_name, *method_args, **opts)
+
+          value = value.__value__ while Thunk === value
+
+          return_port << value
+        end
       end
     end
 
     object
+  rescue => e
+    # :nocov:
+    ::Kernel.puts
+    ::Kernel.puts "an error!!! #{e.class} #{e.message} #{e}"
+    ::Kernel.puts e.backtrace
+    ::Kernel.puts
+
+    raise
+    # :nocov:
   end
 
   class << self
     def ractorize_object(object)
-      RactorizedObject.new(object)
+      RactorizedObject.new(:object, object)
     end
 
     def ractorize_class(klass)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractorize
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Miles Georgi