ractorize 0.0.7 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02d57de76c96c80c8fa5d7a49dcc54a12e9c7f849ff8951faba91806ff5dadbb
-  data.tar.gz: e6ae43cf484790673a4010505622b7255a09b7a5d04f358a2b5a8bec0ab6b917
+  metadata.gz: 72a53fba452511ad30a39dc46714c285570a2904f167c960e97d519e63ee1829
+  data.tar.gz: 77c170a01ff7ec50bfb63c8c70b905be6d999bdaa2b8cd0e3826afd7bc5bb9d1
 SHA512:
-  metadata.gz: 5034e676239f3e6ccd3ea1aa83a0923c0b439800127fd1a3444c08ce93de706f48b05f87e68d697cddb6612d42d7ca057b1b29adef5954ca5b51575cd1320050
-  data.tar.gz: 461059bac8aeea154ec67ed22ed530ac7f8921902bef688d7a5d21927e67adaaab582e2bc528b7a556b4c1fb733a37b9a9202bf261eb6d048125761d516a720f
+  metadata.gz: 3655da0fc231e1d6b5c9bd063cf8e676ab6a9ce7f3b09421e48d085978257574bbbf988d538acb190dd0512d3838b5fe49a9436fa85e65f67a09aebfe137ff8b
+  data.tar.gz: 0dad22a3bf13eedff038063711e18e473b25f5e6e760b3b400de4603996240f71d3635788c8f06e2705da2a8103df236c5c76f94303ff44900122baedd368a9d

data/CHANGELOG.md

@@ -1,3 +1,18 @@
+## [0.0.9] - 2026-06-29
+
+- Fix bug that results from moving Time, which is neither shareable nor movable!
+- Handle deadlocks that seem to arise from re-entrant #inspect calls
+
+## [0.0.8] - 2026-06-24
+
+- Add GarbageCollector to close abandoned RactorizedObject ractors and Thunk ractors
+- Switch thunks to work off of Ractor instead of Ractor::Port due to port/ractor leaks
+- Block on #hash and delegate to super in #==/#!=
+- Significant test suite improvements:
+  - Remove awkward RACTORIZE_PROC tests and instead use the shmactor gem to get to 100% branch coverage
+  - Parallelize the build and run a shmactor build to get full coverage of ractor procs
+  - Check for leaked ractors/ports after test suite and fail the build on any memory leaks
+
 ## [0.0.7] - 2026-06-06
 
 - Closed Ractor::Ports sometimes give IOError instead of Ractor::ClosedError so handle both

data/src/ractorize/base_ractor.rb

@@ -0,0 +1,2 @@
+# We do it this way to allow easily swapping out with Shmactor
+BaseRactor ||= Ractor # rubocop:disable Lint/OrAssignmentToConstant

data/src/ractorize/garbage_collection/tracker.rb

@@ -0,0 +1,35 @@
+module Ractorize
+  module GarbageCollection
+    class Tracker
+      attr_accessor :ractorized_object_id_to_ractor,
+                    :thunk_id_to_ractor
+
+      def initialize
+        self.ractorized_object_id_to_ractor = ObjectSpace::WeakMap.new
+        self.thunk_id_to_ractor = ObjectSpace::WeakMap.new
+      end
+
+      def track_ractorized_object(ractorized_object)
+        ractorized_object_id_to_ractor[ractorized_object.__object_id__] = ractorized_object.__ractor__
+      end
+
+      def cleanup_after_ractorized_object(ractorized_object_id)
+        ractor = ractorized_object_id_to_ractor.delete(ractorized_object_id)
+        ractor&.<<(:__close__)
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+
+      def track_thunk(thunk_id, ractor)
+        thunk_id_to_ractor[thunk_id] = ractor
+      end
+
+      def cleanup_after_thunk(thunk_id)
+        ractor = thunk_id_to_ractor.delete(thunk_id)
+        ractor&.<<(:__close__)
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+    end
+  end
+end

data/src/ractorize/garbage_collection/tracking_ractor.rb

@@ -0,0 +1,38 @@
+require_relative "../base_ractor"
+require_relative "tracker"
+
+module Ractorize
+  module GarbageCollection
+    class TrackingRactor < BaseRactor
+      class << self
+        def new
+          super(name: "GarbageCollection::TrackingRactor") do
+            tracker = Tracker.new
+
+            loop do
+              # SimpleCov branch coverage doesn't like that we aren't testing not matching anything
+              # but this does result in an error unlike case/when so no point in checking that.
+              # :nocov:
+              case receive
+                # :nocov:
+              in :track_ractorized_object, ractorized_object
+                tracker.track_ractorized_object(ractorized_object)
+              in :cleanup_after_ractorized_object, ractorized_object_id
+                tracker.cleanup_after_ractorized_object(ractorized_object_id)
+              in :track_thunk, thunk_id, thunk_ractor
+                tracker.track_thunk(thunk_id, thunk_ractor)
+              in :cleanup_after_thunk, thunk_id
+                tracker.cleanup_after_thunk(thunk_id)
+              end
+            rescue TrackingRactor::ClosedError
+              # do nothing
+            end
+          end
+        end
+      end
+    end
+
+    TRACKING_RACTOR = TrackingRactor.new
+    private_constant :TRACKING_RACTOR
+  end
+end

data/src/ractorize/garbage_collection.rb

@@ -0,0 +1,54 @@
+module Ractorize
+  module GarbageCollection
+    class << self
+      def track_ractorized_object(ractorized_object)
+        # We have to define the finalizer here, not in the tracker, because it's not frozen yet
+        ObjectSpace.define_finalizer(ractorized_object, &finalize_proc)
+        Object.instance_method(:freeze).bind_call(ractorized_object)
+
+        begin
+          TRACKING_RACTOR << [:track_ractorized_object, ractorized_object].freeze
+        rescue TrackingRactor::ClosedError
+          # do nothing
+        end
+      end
+
+      def track_thunk(thunk)
+        # We have to define the finalizer here, not in the tracker, because it's not frozen yet
+        ObjectSpace.define_finalizer(thunk, &finalize_thunk_proc)
+
+        begin
+          TRACKING_RACTOR << [:track_thunk, thunk.__object_id__, thunk.__thunk_ractor__].freeze
+        rescue TrackingRactor::ClosedError
+          # do nothing
+        end
+      end
+
+      def cleanup_after_ractorized_object(ractorized_object_id)
+        TRACKING_RACTOR << [:cleanup_after_ractorized_object, ractorized_object_id].freeze
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+
+      def cleanup_after_thunk(thunk_id)
+        TRACKING_RACTOR << [:cleanup_after_thunk, thunk_id].freeze
+      rescue Ractor::ClosedError
+        # do nothing
+      end
+
+      private
+
+      def finalize_proc
+        proc do |ractorized_object_id|
+          ::Ractorize::GarbageCollection.cleanup_after_ractorized_object(ractorized_object_id)
+        end
+      end
+
+      def finalize_thunk_proc
+        proc do |thunk_id|
+          ::Ractorize::GarbageCollection.cleanup_after_thunk(thunk_id)
+        end
+      end
+    end
+  end
+end

data/src/ractorize/ractorized_object/ractorized_ractor.rb

@@ -0,0 +1,133 @@
+require_relative "../base_ractor"
+
+module Ractorize
+  class RactorizedObject < BasicObject
+    class RactorizedRactor < ::BaseRactor
+      class << self
+        def new(name: nil)
+          super do
+            mode = receive
+
+            object = case mode
+                     when :class
+                       klass, args, opts, block = receive
+                       target_class = klass
+                       klass.new(*args.freeze, **opts.freeze, &block)
+                     when :object
+                       o = receive
+                       target_class = o.class
+                       o
+                     when :class_arg_by_arg
+                       klass = receive
+                       target_class = klass
+
+                       args, opts, block = Ractorize.extract_args(self)
+
+                       klass.new(*args.freeze, **opts.freeze, &block)
+                     else
+                       # :nocov:
+                       raise "Invalid mode #{mode}"
+                       # :nocov:
+                     end
+
+            loop do
+              # rubocop:disable Lint/UselessAssignment
+              value = method_name = method_args = opts = return_port = thunk_ractor = block_given = nil
+              # rubocop:enable Lint/UselessAssignment
+              method_name, method_args, opts, return_port, thunk_ractor, block_given = receive
+
+              case method_name
+              when :__close__
+                begin
+                  # Time is not movable but also not shareable!
+                  move = !Ractor.shareable?(object) && !(Time === object)
+                  thunk_ractor&.send([:success, object].freeze, move:)
+                rescue RactorizedRactor::ClosedError
+                  # do nothing
+                end
+
+                object = nil
+                close
+                break
+              when :__target_object_id__
+                return_port = method_args
+
+                target_object_id = ::Object.instance_method(:object_id).bind_call(object)
+                return_port << target_object_id
+              else
+                if method_name == :__invoke_arg_by_arg__
+                  args_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
+                  return_port << args_port
+
+                  method_name = args_port.receive
+                  method_args, opts = Ractorize.extract_args(args_port)
+                end
+
+                if block_given
+                  block_result_port = Ractorize::RactorizedObject::RactorizedRactor::Port.new
+
+                  value = object.__send__(method_name, *method_args, **opts) do |*args, **opts, &b|
+                    Ractorize.prepare_args(target_class, args, opts, skip_move: true)
+
+                    return_port << [:yield, [args.dup.freeze, opts.dup.freeze, b].freeze, block_result_port].freeze
+
+                    outcome_type, return_value = block_result_port.receive
+
+                    case outcome_type
+                    when :normal
+                      return_value
+                    when :break
+                      # TODO: handle error situation
+                      break
+                    else
+                      # :nocov:
+                      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 Ractorize::Thunk === value
+
+                  begin
+                    if thunk_ractor
+                      thunk_ractor.send([:success, value].freeze)
+                    else
+                      return_port << value
+                    end
+                  rescue IOError => e
+                    # Unclear why this sometimes manifests as this error instead of ClosedError but
+                    # need to handle them both.
+                    # :nocov:
+                    raise unless e.message == "closed stream"
+                    # :nocov:
+                  rescue Ractor::ClosedError
+                    # Whoa... this error inherits from StopIteration and will kill the loop!!!
+                    # Nothing really to do here but keep the loop going and handle other
+                    # method calls to the ractorized object from other ractors.
+                  end
+                end
+              end
+
+              nil
+            end
+
+            nil
+          # object
+          rescue => e
+            # :nocov:
+            puts
+            puts "an unhandled error!!! #{e.class} #{e.message} #{e}"
+            puts e.backtrace
+            puts
+
+            raise
+            # :nocov:
+          end
+        end
+      end
+    end
+  end
+end

data/src/ractorize/ractorized_object.rb

@@ -3,22 +3,32 @@ require_relative "thunk"
 
 module Ractorize
   class RactorizedObject < BasicObject
+    class << self
+      def method_should_use_thunk?(method_symbol)
+        method_symbol != :== && method_symbol != :! && method_symbol != :!= &&
+          method_symbol != :inspect && method_symbol != :to_s &&
+          !method_symbol.end_with?("?") && method_symbol != :hash
+      end
+    end
+
+    attr_reader :__object_id__, :__ractor__
+
     def initialize(mode, *args, **opts, &block)
-      @ractor = ::Ractor.new(name: "#{args.first}<#{args.first.object_id}>", &RACTOR_PROC)
+      @__ractor__ = RactorizedRactor.new(name: "#{args.first}<#{args.first.object_id}>".freeze)
 
       case mode
       when :object
-        @ractor << :object
+        @__ractor__ << :object
 
         outside_object = args.first
-
+        @__target_object_id__ = ::Object.instance_method(:object_id).bind_call(outside_object)
         @__target_class__ = outside_object.class
 
         if ::Ractor.shareable?(outside_object)
-          @ractor << outside_object
+          @__ractor__ << outside_object
         else
           ::Ractorize.resolve_all_thunks(outside_object)
-          @ractor.send(outside_object, move: true)
+          @__ractor__.send(outside_object, move: true)
         end
       when :class
         klass, *args = args
@@ -28,60 +38,69 @@ module Ractorize
         to_move = ::Ractorize.prepare_args(@__target_class__, args, opts)
 
         if to_move&.any?
-          @ractor << :class_arg_by_arg
-          @ractor << klass
+          @__ractor__ << :class_arg_by_arg
+          @__ractor__ << klass
 
           args.each do |arg|
-            @ractor << :arg
-            @ractor.send(arg, move: to_move.include?(arg))
+            @__ractor__ << :arg
+            @__ractor__.send(arg, move: to_move.include?(arg))
           end
 
           opts.each_pair do |name, value|
-            @ractor << :kwarg
-            @ractor << name
-            @ractor.send(value, move: to_move.include?(value))
+            @__ractor__ << :kwarg
+            @__ractor__ << name
+            @__ractor__.send(value, move: to_move.include?(value))
           end
 
           if block
-            @ractor << :block
-            @ractor << block
+            @__ractor__ << :block
+            @__ractor__ << block
           end
 
-          @ractor << :done
+          @__ractor__ << :done
         else
-          @ractor << :class
-          @ractor << [klass, args.freeze, opts.dup.freeze, block].freeze
+          @__ractor__ << :class
+          @__ractor__ << [klass, args.freeze, opts.dup.freeze, block].freeze
         end
+
+        return_port = ::Ractor::Port.new
+        @__ractor__ << [:__target_object_id__, return_port].freeze
+        @__target_object_id__ = return_port.receive
       else
         # :nocov:
         ::Kernel.raise "Invalid mode #{mode}"
         # :nocov:
       end
 
-      ::Object.instance_method(:freeze).bind(self).call
+      @__object_id__ = ::Object.instance_method(:object_id).bind_call(self)
+
+      ::Ractorize::GarbageCollection.track_ractorized_object(self)
     end
 
     def __close__ = method_missing(:__close__)
 
     def __join__
       __close__
-      @ractor.join
+      @__ractor__.join
       self
     end
 
     def method_missing(method_name, *args, **opts, &block)
-      if @ractor.default_port.closed?
+      if @__ractor__.default_port.closed?
         ::Kernel.raise ::Ractor::ClosedError,
                        "You already closed this Ractorized instance of #{@__target_class__}!\n" \
                        "No more methods can be sent to it but you sent #{method_name}"
       end
 
-      return_port = ::Ractor::Port.new
+      return_port = ::Ractorize::RactorizedObject::RactorizedRactor::Port.new
+      thunk_ractor = if !block && RactorizedObject.method_should_use_thunk?(method_name)
+                       ::Ractorize::Thunk::ThunkRactor.new
+                     end
 
       to_move = ::Ractorize.prepare_args(@__target_class__, args, opts)
 
       if to_move&.any?
-        @ractor << [:__invoke_arg_by_arg__, [].freeze, {}.freeze, return_port, !!block]
+        @__ractor__ << [:__invoke_arg_by_arg__, [].freeze, {}.freeze, return_port, thunk_ractor, !!block]
 
         args_port = return_port.receive
         args_port << method_name
@@ -99,7 +118,7 @@ module Ractorize
 
         args_port << :done
       else
-        @ractor << [method_name, args.dup.freeze, opts.dup.freeze, return_port, !!block].freeze
+        @__ractor__ << [method_name, args.dup.freeze, opts.dup.freeze, return_port, thunk_ractor, !!block].freeze
       end
 
       if block
@@ -121,28 +140,38 @@ module Ractorize
             # 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
+            begin
+              broke = true
+              block_result = block.call(*yielded_args.freeze, **yielded_opts.freeze, &yielded_block)
+              broke = false
+            ensure
+              block_result = block_result.__value__ while ::Ractorize::Thunk === block_result
+
+              block_result_port << if broke
+                                     # TODO: handle error situation
+                                     :break
+                                   else
+                                     [:normal, block_result].freeze
+                                   end
+            end
           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)
-      elsif method_name == :== || method_name == :! || method_name == :!= ||
-            method_name == :inspect || method_name == :to_s || method_name.end_with?("?")
+      elsif thunk_ractor
+        return_port.close
+        Thunk.new(thunk_ractor)
+      else
         value = return_port.receive
+        return_port.close
 
         # :nocov:
         ::Kernel.raise ::Ractorize::Thunk::EscapingRactorError if ::Ractorize::Thunk === value
         # :nocov:
 
         value
-      else
-        Thunk.new(return_port)
       end
     end
 
@@ -159,18 +188,17 @@ module Ractorize
       method_missing(:respond_to?, method_name, include_all)
     end
 
-    def ==(other) = method_missing(:==, other)
-    def !=(other) = method_missing(:==, other)
+    def ==(other) = method_missing(:==, other) || super
+    def !=(other) = method_missing(:==, other) || super
     def ! = method_missing(:!)
-    def equal?(other) = method_missing(:equal?, other)
-
+    # def equal?(other) = method_missing(:equal?, other) || super
     def to_s = inspect
 
+    # delegating this to the target object increases risk of a deadlock since
+    # sometimes #inspect calls #inspect on other objects and can lead to reentry and thus deadlock
     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
+      "RactorizedObject<#{object_id}>[#{@__target_class__}<#{@__target_object_id__}>]}"
     end
   end
 end

data/src/ractorize/thunk/thunk_ractor.rb

@@ -0,0 +1,23 @@
+require_relative "../base_ractor"
+
+module Ractorize
+  class Thunk < BasicObject
+    class ThunkRactor < ::BaseRactor
+      class << self
+        def new
+          super do
+            # SimpleCov seems to want us to handle the case where nothing matches but that would be an error
+            # :nocov:
+            case receive
+            # :nocov:
+            in :__close__
+              # do nothing
+            in :success, value
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/src/ractorize/thunk.rb

@@ -2,14 +2,18 @@ module Ractorize
   class Thunk < BasicObject
     class EscapingRactorError < ::StandardError; end
 
-    attr_accessor :__return_value_port__, :__ractor__
+    attr_accessor :__thunk_ractor__, :__object_id__
 
-    def initialize(return_value_port)
-      self.__ractor__ = ::Ractor.current
-      self.__return_value_port__ = return_value_port
+    def initialize(return_value_portlike)
+      self.__thunk_ractor__ = return_value_portlike
+      self.__object_id__ = ::Object.instance_method(:object_id).bind_call(self)
+      ::Ractorize::GarbageCollection.track_thunk(self)
     end
 
     def initialize_clone(...)
+      # :nocov:
+      raise "CAREFUL! THUNK CLONED!!"
+      # :nocov:
       # is this actually necessary?? Seems so?
     end
 
@@ -24,24 +28,11 @@ module Ractorize
     def __value__
       return @__value__ if defined?(@__value__)
 
-      value = if ::Ractor.current == __ractor__
-                __return_value_port__.receive
-              else
-                # :nocov:
-                ::Kernel.raise EscapingRactorError,
-                               "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__ = __thunk_ractor__.join.value
+      self.__thunk_ractor__ = nil
+      ::Object.instance_method(:freeze).bind_call(self)
 
-      value
+      @__value__
     end
 
     def ! = !__value__

data/src/ractorize.rb

@@ -4,6 +4,22 @@ require_relative "ractorize/ractorized_class"
 
 module Ractorize
   class << self
+    def ractorize_object(object)
+      RactorizedObject.new(:object, object)
+    end
+
+    def ractorize_class(klass)
+      RactorizedClass[klass]
+    end
+
+    def [](object)
+      if object.is_a?(Class)
+        ractorize_class(object)
+      else
+        ractorize_object(object)
+      end
+    end
+
     # TODO: figure out a way to magically get a ractor-shareable proc from a non-ractor-shareable proc
     def auto_freeze(target, class_or_proc = nil)
       @auto_freeze = @auto_freeze ? @auto_freeze.dup : []
@@ -64,6 +80,7 @@ module Ractorize
     # Not sure why that is but we need to handle that case.
     def resolve_all_thunks(structure)
       each_thunk(structure, &:__value__)
+      nil
     end
 
     def to_move(target_class, args)
@@ -147,28 +164,8 @@ module Ractorize
       to_move(target_class, args)
     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
+    def each_thunk(structure, seen = Set.new, &)
+      each_instance_of(Thunk, structure, seen, 0, &)
     end
 
     def extract_args(port_like)
@@ -200,123 +197,37 @@ module Ractorize
 
       [args, opts, block]
     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
-    mode = receive
-
-    object = case mode
-             when :class
-               klass, args, opts, block = receive
-               target_class = klass
-               klass.new(*args.freeze, **opts.freeze, &block)
-             when :object
-               o = receive
-               target_class = o.class
-               o
-             when :class_arg_by_arg
-               klass = receive
-               target_class = klass
-
-               args, opts, block = Ractorize.extract_args(self)
-
-               klass.new(*args.freeze, **opts.freeze, &block)
-             else
-               # :nocov:
-               raise "Invalid mode #{mode}"
-               # :nocov:
-             end
-
-    loop do
-      method_name, method_args, opts, return_port, block_given = receive
-
-      case method_name
-      when :__close__
-        return_port.<<(object, move: true)
-        close
-        break
-      else
-        if method_name == :__invoke_arg_by_arg__
-          args_port = Ractor::Port.new
-          return_port << args_port
-
-          method_name = args_port.receive
-          method_args, opts = Ractorize.extract_args(args_port)
-        end
-
-        if block_given
-          block_result_port = Ractor::Port.new
 
-          value = object.__send__(method_name, *method_args, **opts) do |*args, **opts, &b|
-            Ractorize.prepare_args(target_class, args, opts, skip_move: true)
+    private
 
-            return_port << [:yield, [args.dup.freeze, opts.dup.freeze, b].freeze, block_result_port].freeze
+    def each_instance_of(klass, structure, seen = Set.new, depth = 0, &block)
+      depth += 1
+      if klass === structure
+        block.call(structure)
+      end
+      return if seen.include?(structure)
 
-            outcome_type, return_value = block_result_port.receive
+      seen << structure
 
-            case outcome_type
-            when :normal
-              return_value
-            when :break
-              break return_value
-            else
-              # :nocov:
-              raise "Not sure how to handle outcome_type #{outcome_type}"
-              # :nocov:
-            end
-          end
+      case structure
+      when Array
+        structure.each { each_instance_of(klass, it, seen, depth, &block) }
+      when Hash
+        each_instance_of(klass, structure.keys, seen, depth, &block)
+        each_instance_of(klass, structure.values, seen, depth, &block)
+      when Struct
+        each_instance_of(klass, structure.values, seen, depth, &block)
+      else
+        ivarsget = ::Object.instance_method(:instance_variables)
+        iget = ::Object.instance_method(:instance_variable_get)
 
-          return_port << [:return, value].freeze
-        else
-          value = object.__send__(method_name, *method_args, **opts)
-          value = value.__value__ while Ractorize::Thunk === value
-
-          begin
-            return_port.send(value)
-          rescue IOError => e
-            # Unclear why this sometimes manifests as this error instead of ClosedError but
-            # need to handle them both.
-            # :nocov:
-            raise unless e.message == "closed stream"
-            # :nocov:
-          rescue Ractor::ClosedError
-            # Whoa... this error inherits from StopIteration and will kill the loop!!!
-            # Nothing really to do here but keep the loop going and handle other
-            # method calls to the ractorized object from other ractors.
-          end
+        ivarsget.bind(structure).call.each do |var|
+          value = iget.bind(structure).call(var)
+          each_instance_of(klass, value, seen, depth, &block)
         end
       end
-    end
-
-    object
-  rescue => e
-    # :nocov:
-    puts
-    puts "an unhandled error!!! #{e.class} #{e.message} #{e}"
-    puts e.backtrace
-    puts
 
-    raise
-    # :nocov:
-  end
-
-  class << self
-    def ractorize_object(object)
-      RactorizedObject.new(:object, object)
-    end
-
-    def ractorize_class(klass)
-      RactorizedClass[klass]
-    end
-
-    def [](object)
-      if object.is_a?(Class)
-        ractorize_class(object)
-      else
-        ractorize_object(object)
-      end
+      nil
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractorize
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors:
 - Miles Georgi
@@ -21,9 +21,15 @@ files:
 - README.md
 - lib/ractorize.rb
 - src/ractorize.rb
+- src/ractorize/base_ractor.rb
+- src/ractorize/garbage_collection.rb
+- src/ractorize/garbage_collection/tracker.rb
+- src/ractorize/garbage_collection/tracking_ractor.rb
 - src/ractorize/ractorized_class.rb
 - src/ractorize/ractorized_object.rb
+- src/ractorize/ractorized_object/ractorized_ractor.rb
 - src/ractorize/thunk.rb
+- src/ractorize/thunk/thunk_ractor.rb
 homepage: https://github.com/ractor-shack/ractorize
 licenses:
 - MPL-2.0