ractorize 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ea9fd31cee6cae0ef89ff10256f4b3697e472e0311bb792c77f93f750be4f3a
-  data.tar.gz: 7468ea66e37593b5ff8c5ac26087cdd0de1134bef7d1d9bb5c468371c5e1f537
+  metadata.gz: 259d8a0f04fdab353871748575089e83199cfad7d81440d4e6f3a957366c9301
+  data.tar.gz: e05e67142fdd2c081ec6baf244df8f7dadf991437c12e7d27cc87c793c863956
 SHA512:
-  metadata.gz: 7a41390e8c9f98222862a5ff2a486d78800d01cb96ccf8833ecfed9348121b5300c95b33dae9e0052ef2a875c49e6f1ad84dc2b8017a9e3925816b854a56fe23
-  data.tar.gz: b1e621b39d666b81006e47b5d9cea508ab773e18810a94c1a637d77c70eb84a9081e9e67a54ddb580a7874687202106c17fc6e7b8c60115600ae700864d18b6b
+  metadata.gz: ebd8a74f6bd6040740c5d41adb81f4caba0508ec28f1025eedb8a2feef826f5f09d764535593d464d3355bebe64941138f5789c9792223df8fe095af7384d985
+  data.tar.gz: 30b2f4d65a70d7218b5e3d76b1f6c04f3cb0c784fe8cd639d53770705caa61163c5c84ba678cd725f8f19296c1c6d985c6310ff461dbade04015522f96a8b155

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [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,40 @@ 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)
-
-      @__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, opts, return_port]
 
+      # 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
+      else
         Thunk.new(return_port)
       end
     end
@@ -56,13 +51,7 @@ 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
   end
 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,7 +12,7 @@ module Ractorize
       method_name, method_args, opts, return_port = receive
 
       case method_name
-      when :close
+      when :__close__
         return_port.<<(object, move: true)
         close
         break
@@ -20,6 +22,8 @@ module Ractorize
         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.2
 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: []