ractorize 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ea9fd31cee6cae0ef89ff10256f4b3697e472e0311bb792c77f93f750be4f3a
-  data.tar.gz: 7468ea66e37593b5ff8c5ac26087cdd0de1134bef7d1d9bb5c468371c5e1f537
+  metadata.gz: f4125b52255fca881ea212e46e55e4c795e79b39f8d8369580022e67db2eb9a8
+  data.tar.gz: 91f58df84879ac297d0111f5880faf8ea95804fdb4ae17345f7702e579fbfb42
 SHA512:
-  metadata.gz: 7a41390e8c9f98222862a5ff2a486d78800d01cb96ccf8833ecfed9348121b5300c95b33dae9e0052ef2a875c49e6f1ad84dc2b8017a9e3925816b854a56fe23
-  data.tar.gz: b1e621b39d666b81006e47b5d9cea508ab773e18810a94c1a637d77c70eb84a9081e9e67a54ddb580a7874687202106c17fc6e7b8c60115600ae700864d18b6b
+  metadata.gz: 691e4eb2b5a1d436b366e93256e7af917308ea3ca3292205791023f92948202464279d4e11e3251c9d842ac63e79a1d5e1a3c377747e07ced9956722a67e2d68
+  data.tar.gz: ef0e4f07687797d2036f326674150ba9ff1e5e07a604936109f4ff0e0811bb19de85d22a5834c8684ed49860cc4f27943d3a292960378c46a2c661f561e91b05

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [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.
+- Make sure methods don't collide with core methods: #join/#close -> #__join__/#__close__
+
 ## [0.0.1] - 2026-04-14
 
 - Initial release

data/README.md

@@ -1,6 +1,6 @@
 # Ractorize
 
-Have an object you wish was a ractor but isn't? Well, this gem lets you ractorize it!
+Have an object you wish were a ractor but isn't? Well, this gem lets you ractorize it!
 
 When you ractorize an object, you can just call the normal methods on the object as if it weren't a ractor.
 These method calls will automatically be sent as messages to a different ractor where that
@@ -50,12 +50,12 @@ also ractorize individual objects with `Ractorize[some_object]`.
 Notice how, whether it's ractorized or not, we can just use the same exact interface? Fun!
 
 You can find a script that benchmarks these the ractorized versus non-ractorized
-approach in `example_scripts/product-benchmark2`.
+approach in `example_scripts/product-benchmark`.
 
-Here's an example run of the product-benchmark2 script:
+Here's an example run of the product-benchmark script:
 
 ```
-$ example_scripts/product-benchmark2
+$ example_scripts/product-benchmark
 benchmarking non-ractorized productizer
 product is 0.568147e51
 took 2.303 seconds
@@ -68,6 +68,54 @@ took 0.195 seconds
 $
 ```
 
+## Gotchas
+
+### Predicate methods not ending in "?" will always return truthy values!
+If you try to use the return value of a ractorized object (or any instance of a ractorized class)
+in a boolean expression, it will always be truthy!!
+
+You need to instead call `#__value__` on it to force it into the real value. This will make it block, but
+that's what you want anyways in such a situation.
+
+Example:
+
+```ruby
+class String
+  def is_empty = empty?
+end
+
+if Ractorize["asdf"].is_empty
+  puts "It's empty!"
+else
+  puts "It's not empty!"
+end
+```
+
+This will incorrectly print out `It's empty!`! To make it work you can force it to block and wait
+for the actual value and use the actual value with the `#__value__` method:
+
+```ruby
+class String
+  def is_empty = empty?
+end
+
+if Ractorize["asdf"].is_empty.__value__
+  puts "It's empty!"
+else
+  puts "It's not empty!"
+end
+```
+
+This will correctly print out `It's not empty!`.
+
+### Calling a method on a closed ractorized object might result in a deadlock!
+
+It will usually raise a `Ractor::CloseError` but once in a while it can deadlock.
+
+Note that if you call either `#__close__` or `#__join__` on the object, then the underlying ractor will be closed.
+
+An easy way to avoid the deadlock is just don't make any use of such an object after closing it.
+
 ## Fine print
 
 Ractors are still experimental and so this gem is also still experimental.

data/src/ractorize/ractorized_object.rb

@@ -3,45 +3,44 @@ require_relative "thunk"
 
 module Ractorize
   class RactorizedObject < BasicObject
-    # 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.
-
-    attr_accessor :__object__
-
     def initialize(outside_object)
       @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)
-    end
-
-    def close
-      result = method_missing(:close)
+      if ::Ractor.shareable?(outside_object)
+        @ractor << outside_object
+      else
+        @ractor.send(outside_object, move: true)
+      end
 
-      @__object__ = if Thunk === result
-                      result.__value__
-                    else
-                      result
-                    end
+      # Wow, this works! Scary?
+      ::Object.instance_method(:freeze).bind(self).call
     end
 
-    def join
-      close
+    def __close__ = method_missing(:__close__)
+
+    def __join__
+      __close__
       @ractor.join
       self
     end
 
     def method_missing(method_name, *args, **opts)
-      return @__object__ if method_name == :close && @ractor.default_port.closed?
+      if @ractor.default_port.closed?
+        ::Kernel.raise ::Ractor::ClosedError,
+                       "You already closed this Ractorized object! No more methods can be sent to it."
+      end
 
-      if defined?(@__object__)
-        @__object__.__send__(method_name, *args, **opts)
-      else
-        return_port = ::Ractor::Port.new
+      return_port = ::Ractor::Port.new
 
-        @ractor << [method_name, args, opts, return_port]
+      @ractor << [method_name, args.dup.freeze, opts.dup.freeze, return_port].freeze
 
+      # 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 == :== || method_name == :! || method_name == :!= || method_name.end_with?("?")
+        return_port.receive
+      else
         Thunk.new(return_port)
       end
     end
@@ -56,13 +55,12 @@ module Ractorize
     end
 
     def respond_to_missing?(method_name, include_all = false)
-      value = method_missing(:respond_to?, method_name, include_all)
-
-      if ::Ractorize::Thunk === value
-        value.__value__
-      else
-        value
-      end
+      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)
   end
 end

data/src/ractorize/thunk.rb

@@ -6,6 +6,10 @@ module Ractorize
       self.__return_value_port__ = return_value_port
     end
 
+    def initialize_clone(...)
+      # is this actually necessary?? Seems so?
+    end
+
     def method_missing(method_name, *)
       __value__.send(method_name, *)
     end

data/src/ractorize.rb

@@ -3,6 +3,8 @@ require_relative "ractorize/ractorized_object"
 require_relative "ractorize/ractorized_class"
 
 module Ractorize
+  # 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
 
@@ -10,16 +12,20 @@ module Ractorize
       method_name, method_args, opts, return_port = receive
 
       case method_name
-      when :close
+      when :__close__
         return_port.<<(object, move: true)
         close
         break
       else
         value = object.__send__(method_name, *method_args, **opts)
 
+        value = value.__value__ while Thunk === value
+
         return_port << value
       end
     end
+
+    object
   end
 
   class << self

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ractorize
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Miles Georgi
@@ -46,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Turn objects into ractors with ease!
 test_files: []