Make what is automatically moved configurable and add an auto-freeze feature

Author: azimux

.rubocop.yml

@@ -25,3 +25,6 @@ Style/DoubleNegation:
 
 Naming/MethodParameterName:
   Enabled: false
+
+RSpec/DescribedClass:
+  Enabled: false

spec/auto_freeze_spec.rb

@@ -0,0 +1,116 @@
+RSpec.describe Ractorize do
+  describe ".auto_freeze" do
+    around do |example|
+      old_to_move = described_class.instance_variable_get(:@auto_freeze).dup
+
+      example.run
+    ensure
+      described_class.instance_variable_set(:@auto_freeze, old_to_move)
+    end
+
+    let(:foo_klass) do
+      stub_class("Foo") do
+        def foo(bar) = bar
+      end
+    end
+    let(:ractorized_foo) { Ractorize[foo_klass.new] }
+    let(:bar_klass) do
+      stub_class("Bar") do
+        def bar(baz) = baz
+      end
+    end
+    let(:ractorized_bar) { Ractorize[bar_klass.new] }
+
+    context "when auto-freezing all strings" do
+      before do
+        Ractorize.auto_freeze(String)
+      end
+
+      it "automatically freezes strings that are passed to a ractorized object to prevent duplication" do
+        s = "asdf"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq(s)
+        }.to change(s, :frozen?).from(false).to(true)
+      end
+
+      context "when the thing to freeze is super deep in the structure" do
+        it "still freezes it" do
+          s = "asdf"
+          structure = {
+            foo: [1, 2, s]
+          }
+
+          expect {
+            expect(ractorized_foo.foo(structure)).to eq(structure)
+          }.to change(s, :frozen?).from(false).to(true)
+        end
+
+        context "when freezing something makes something shareable" do
+          it "works just fine without needing to consider the rest of the structure" do
+            s = "asdf"
+            structure = {
+              foo: [1, 2, s].freeze
+            }.freeze
+
+            expect {
+              expect(ractorized_foo.foo(structure)).to eq(structure)
+            }.to change { Ractor.shareable?(structure) }.from(false).to(true)
+          end
+        end
+      end
+    end
+
+    context "when auto-freezing a class for different ractorized object classes" do
+      before do
+        Ractorize.auto_freeze(foo_klass, String)
+      end
+
+      it "freezes objects only when the target class matches the rule" do
+        s = "asdf"
+
+        expect {
+          expect(ractorized_bar.bar(s)).to eq(s)
+        }.to_not change(s, :frozen?)
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq(s)
+        }.to change(s, :frozen?).from(false).to(true)
+      end
+    end
+
+    context "when it's already frozen" do
+      it "works just fine" do
+        s = "asdf"
+        expect(ractorized_foo.foo(s)).to eq(s)
+      end
+    end
+
+    context "when using procs to determine if something should be frozen" do
+      before do
+        Ractorize.auto_freeze(Ractor.shareable_proc { it =~ /quux/ })
+        Ractorize.auto_freeze(Ractor.shareable_proc { it =~ /baz/ })
+      end
+
+      it "only freezes when it matches the rule proc" do
+        s = "foo"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq(s)
+        }.to_not change(s, :frozen?)
+
+        s = "bar"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq(s)
+        }.to_not change(s, :frozen?)
+
+        s = "baz"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq(s)
+        }.to change(s, :frozen?).from(false).to(true)
+      end
+    end
+  end
+end

spec/move_arg_spec.rb

@@ -0,0 +1,82 @@
+RSpec.describe Ractorize do
+  describe ".move_arg" do
+    around do |example|
+      old_to_move = described_class.instance_variable_get(:@move_arg).dup
+
+      example.run
+    ensure
+      described_class.instance_variable_set(:@move_arg, old_to_move)
+    end
+
+    let(:foo_klass) do
+      stub_class("Foo") do
+        def foo(bar) = bar
+      end
+    end
+    let(:ractorized_foo) { Ractorize[foo_klass.new] }
+    let(:bar_klass) do
+      stub_class("Bar") do
+        def bar(baz) = baz
+      end
+    end
+    let(:ractorized_bar) { Ractorize[bar_klass.new] }
+
+    context "when moving all strings" do
+      before do
+        Ractorize.move_arg(String)
+      end
+
+      it "automatically moves strings that are passed to a ractorized object to prevent duplication" do
+        s = "asdf"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq("asdf")
+        }.to change { Ractor::MovedObject === s }.from(false).to(true)
+      end
+    end
+
+    context "when using procs to determine if something should be moved" do
+      before do
+        Ractorize.move_arg(Ractor.shareable_proc { it =~ /baz/ })
+      end
+
+      it "only moves when it matches the rule proc" do
+        s = "foo"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq("foo")
+        }.to_not change { Ractor::MovedObject === s }
+
+        s = "bar"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq("bar")
+        }.to_not change { Ractor::MovedObject === s }
+
+        s = "baz"
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq("baz")
+        }.to change { Ractor::MovedObject === s }.from(false).to(true)
+      end
+    end
+
+    context "when auto-freezing a class for different ractorized object classes" do
+      before do
+        Ractorize.move_arg(foo_klass, String)
+      end
+
+      it "freezes objects only when the target class matches the rule" do
+        s = "asdf"
+
+        expect {
+          expect(ractorized_bar.bar(s)).to eq(s)
+        }.to_not change { Ractor::MovedObject === s }
+
+        expect {
+          expect(ractorized_foo.foo(s)).to eq("asdf")
+        }.to change { Ractor::MovedObject === s }.from(false).to(true)
+      end
+    end
+  end
+end

spec/ractorize_spec.rb

@@ -1,4 +1,16 @@
 RSpec.describe Ractorize do
+  def self.move_string_args
+    before do
+      old_to_move = described_class.instance_variable_get(:@to_move).dup
+
+      begin
+        described_class.move_arg(String)
+      ensure
+        described_class.instance_variable_set(:@to_move, old_to_move)
+      end
+    end
+  end
+
   let(:doubler_class) do
     stub_class("Doubler") do
       class << self
@@ -48,6 +60,8 @@ def double = @i *= 2
       end
 
       context "when passing non-shareable keyword args" do
+        move_string_args
+
         let(:klass) do
           stub_class("Foo") do
             def foo(bar:) = bar
@@ -83,7 +97,9 @@ def foo(bar:) = bar
         end
       end
 
-      context "when creating an instance with non-shareable args" do
+      context "when creating an instance with to-move args" do
+        move_string_args
+
         let(:args) { ["foo"] }
         let(:klass) do
           stub_class("Foo") do