pbt 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1a5d4c94783e479474b521113dcad84959db11c6139780031cf52aff6748e61
-  data.tar.gz: eb112f231d4417963341fb36b585c9b0d4fa8b14f0ac726c51b80c7424542cb1
+  metadata.gz: 2b93d8a06cbff5946bab644527868f42601ccd7521d4d11e3746fa00c279cd62
+  data.tar.gz: ab19c9a123d4408cb49e7a24225bca930d5bd4134000e98a3efc9c233ce97f9c
 SHA512:
-  metadata.gz: e40bde143e84c6ed1fa76cf69f3ed93261bcdae70a229359ea996190c63c24ff9b7155f9974a0d4a39c8430fb17e935539631e463a072af30439b5805c939021
-  data.tar.gz: d082a2078753d09bf19a1bfc41931258a19db3842590c7f366a1f5fece9097b3a6668db096baa9a679ab0026df05e45ac1f03f14ceca0f1b7aeb635bc1f82c83
+  metadata.gz: cd5fd29fb5e5d3afb5817fd24b0c8967037e2158dd3cc57e4d4ab83eb12c7a31c1dfff376a88b96173ca14853cd3d56b89de212c3630bb6cffe4bb4f04b106d6
+  data.tar.gz: b0d37a7198cd0d1c504170f00041b5decab223e73c8896ebd1d357f4482503665ec0ca200cf5557bbed6c04f775cb3c7264eb61b1a42e6b6982f30e90941155e

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.5.0] - 2024-12-30
+
+- [Breaking change] Drop `:process` and `:thread` workers since there are no concrete use cases.
+- [Breaking change] Drop `:experimental_ractor_rspec_integration` option since there are no concrete use cases.
+
+## [0.4.2] - 2024-05-23
+
+- Fix Prism `LoadError` message [#27](https://github.com/ohbarye/pbt/pull/27) by @sambostock
+
 ## [0.4.1] - 2024-05-10
 
 - Fix a bug for experimental_ractor_rspec_integration mode. When a test file name starts with a number, it can't be a constant name.

data/README.md

@@ -8,6 +8,8 @@ A property-based testing tool for Ruby with experimental features that allow you
 
 PBT stands for Property-Based Testing.
 
+As for the results of the parallelization experiment, please refer the talk at RubyKaigi 2024: [Unlocking Potential of Property Based Testing with Ractor](https://rubykaigi.org/2024/presentations/ohbarye.html).
+
 ## What's Property-Based Testing?
 
 Property-Based Testing is a testing methodology that focuses on the properties a system should always satisfy, rather than checking individual examples. Instead of writing tests for predefined inputs and outputs, PBT allows you to specify the general characteristics that your code should adhere to and then automatically generates a wide range of inputs to verify these properties.
@@ -39,29 +41,34 @@ Off course you can install with `gem intstall pbt`.
 ### Simple property
 
 ```ruby
-# Let's say you have a method that returns just a multiplicative inverse.
-def multiplicative_inverse(number)
-  Rational(1, number)
+# Let's say you have your own sort method.
+def sort(array)
+  return array if array.size <= 2 # Here's a bug! It should be 1.
+  pivot, *rest = array
+  left, right = rest.partition { |n| n <= pivot }
+  sort(left) + [pivot] + sort(right)
 end
 
 Pbt.assert do
-  # The given block is executed 100 times with different random numbers.
-  # Besides, the block runs in parallel by Ractor.
-  Pbt.property(Pbt.integer) do |number|
-    result = multiplicative_inverse(number)
-    raise "Result should be the multiplicative inverse of the number" if result * number != 1
+  # The given block is executed 100 times with different arrays with random numbers.
+  # Besides, if you set `worker: :ractor` option to `assert` method, it runs in parallel using Ractor.
+  Pbt.property(Pbt.array(Pbt.integer)) do |numbers|
+    result = sort(numbers)
+    result.each_cons(2) do |x, y|
+      raise "Sort algorithm is wrong." unless x <= y
+    end
   end
 end
 
-# If the function has a bug, the test fails with a counterexample.
-# For example, the multiplicative_inverse method doesn't work for 0 regardless of the behavior is intended or not.
+# If the method has a bug, the test fails and it reports a minimum counterexample.
+# For example, the sort method doesn't work for [0, -1].
 #
 # Pbt::PropertyFailure:
 #   Property failed after 23 test(s)
-#   { seed: 11001296583699917659214176011685741769 }
-#   Counterexample: 0
-#   Shrunk 3 time(s)
-#   Got ZeroDivisionError: divided by 0
+#   seed: 43738985293126714007411539287084402325
+#   counterexample: [0, -1]
+#   Shrunk 40 time(s)
+#   Got RuntimeError: Sort algorithm is wrong.
 ```
 
 ### Explain The Snippet
@@ -92,7 +99,7 @@ Here, we used only one type of arbitrary, `Pbt.integer`. There are many other bu
 In PBT, If a test fails, it attempts to shrink the case that caused the failure into a form that is easier for humans to understand.
 In other words, instead of stopping the test itself the first time it fails and reporting the failed value, it tries to find the minimal value that causes the error.
 
-When there is a test that fails when given an even number, a counterexample of `2` is simpler and easier to understand than `432743417662`.
+When there is a test that fails when given an even number, a counterexample of `[0, -1]` is simpler and easier to understand than any complex example like `[-897860, -930517, 577817, -16302, 310864, 856411, -304517, 86613, -78231]`.
 
 ### Arbitrary
 
@@ -103,16 +110,16 @@ There are many built-in arbitraries in `Pbt`. You can use them to generate rando
 ```ruby
 rng = Random.new
 
-Pbt.integer.generate(rng) # => 42
+Pbt.integer.generate(rng)                  # => 42
 Pbt.integer(min: -1, max: 8).generate(rng) # => Integer between -1 and 8
 
-Pbt.symbol.generate(rng) # => :atq
+Pbt.symbol.generate(rng)                   # => :atq
 
-Pbt.ascii_char.generate(rng) # => "a"
-Pbt.ascii_string.generate(rng) # => "aagjZfao"
+Pbt.ascii_char.generate(rng)               # => "a"
+Pbt.ascii_string.generate(rng)             # => "aagjZfao"
 
-Pbt.boolean.generate(rng) # => true or false
-Pbt.constant(42).generate(rng) # => 42 always
+Pbt.boolean.generate(rng)                  # => true or false
+Pbt.constant(42).generate(rng)             # => 42 always
 ```
 
 #### Composites
@@ -120,15 +127,15 @@ Pbt.constant(42).generate(rng) # => 42 always
 ```ruby
 rng = Random.new
 
-Pbt.array(Pbt.integer).generate(rng) # => [121, -13141, 9825]
-Pbt.array(Pbt.integer, max: 1, empty: true).generate(rng) # => [] or [42] etc.
+Pbt.array(Pbt.integer).generate(rng)                        # => [121, -13141, 9825]
+Pbt.array(Pbt.integer, max: 1, empty: true).generate(rng)   # => [] or [42] etc.
 
-Pbt.tuple(Pbt.symbol, Pbt.integer).generate(rng) # => [:atq, 42]
+Pbt.tuple(Pbt.symbol, Pbt.integer).generate(rng)            # => [:atq, 42]
 
 Pbt.fixed_hash(x: Pbt.symbol, y: Pbt.integer).generate(rng) # => {x: :atq, y: 42}
-Pbt.hash(Pbt.symbol, Pbt.integer).generate(rng) # => {atq: 121, ygab: -1142}
+Pbt.hash(Pbt.symbol, Pbt.integer).generate(rng)             # => {atq: 121, ygab: -1142}
 
-Pbt.one_of(:a, 1, 0.1).generate(rng) # => :a or 1 or 0.1
+Pbt.one_of(:a, 1, 0.1).generate(rng)                        # => :a or 1 or 0.1
 ````
 
 See [ArbitraryMethods](https://github.com/ohbarye/pbt/blob/main/lib/pbt/arbitrary/arbitrary_methods.rb) module for more details.
@@ -144,18 +151,18 @@ When a test fails, you'll see a message like below.
 ```text
 Pbt::PropertyFailure:
   Property failed after 23 test(s)
-  { seed: 11001296583699917659214176011685741769 }
-  Counterexample: 0
-  Shrunk 3 time(s)
-  Got ZeroDivisionError: divided by 0
+  seed: 43738985293126714007411539287084402325
+  counterexample: [0, -1]
+  Shrunk 40 time(s)
+  Got RuntimeError: Sort algorithm is wrong.
   # and backtraces
 ```
 
 You can reproduce the failure by passing the seed to `Pbt.assert`.
 
 ```ruby
-Pbt.assert(seed: 11001296583699917659214176011685741769) do
-  Pbt.property(Pbt.integer) do |number|
+Pbt.assert(seed: 43738985293126714007411539287084402325) do
+  Pbt.property(Pbt.array(Pbt.integer)) do |number|
     # your test
   end
 end
@@ -177,25 +184,29 @@ The verbose mode prints the results of each tested values.
 
 ```text
 Encountered failures were:
-- [152477, 666997, -531468, -92182, 623948, 425913, 656138, 856463, -64529]
-- [76239, 666997, -531468, -92182, 623948]
-- [76239, 666997, -531468]
+- [-897860, -930517, 577817, -16302, 310864, 856411, -304517, 86613, -78231]
+- [310864, 856411, -304517, 86613, -78231]
+- [-304517, 86613, -78231]
 (snipped for README)
-- [2, 163]
-- [2, 11]
+- [0, -3]
+- [0, -2]
+- [0, -1]
 
 Execution summary:
-. × [152477, 666997, -531468, -92182, 623948, 425913, 656138, 856463, -64529]
-. . √ [152477, 666997, -531468, -92182, 623948]
-. . √ [-64529]
-. . × [76239, 666997, -531468, -92182, 623948, 425913, 656138, 856463, -64529]
-. . . × [76239, 666997, -531468, -92182, 623948]
+. × [-897860, -930517, 577817, -16302, 310864, 856411, -304517, 86613, -78231]
+. . √ [-897860, -930517, 577817, -16302, 310864]
+. . √ [-930517, 577817, -16302, 310864, 856411]
+. . √ [577817, -16302, 310864, 856411, -304517]
+. . √ [-16302, 310864, 856411, -304517, 86613]
+. . × [310864, 856411, -304517, 86613, -78231]
 (snipped for README)
-. . . . . . . . . . . . . . . . . √ [2, 21]
-. . . . . . . . . . . . . . . . . × [2, 11]
-. . . . . . . . . . . . . . . . . . √ []
-. . . . . . . . . . . . . . . . . . √ [2, 1]
-. . . . . . . . . . . . . . . . . . √ [2, 0]
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ [-2]
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ []
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . × [0, -1]
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ [0]
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ [-1]
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ []
+. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . √ [0, 0]
 ```
 
 ## Configuration
@@ -207,7 +218,7 @@ Pbt.configure do |config|
   # Whether to print verbose output. Default is `false`.
   config.verbose = false
 
-  # The concurrency method to use. `:ractor`, `:thread`, `:process` and `:none` are supported. Default is `:none`.
+  # The concurrency method to use. `:ractor` and `:none` are supported. Default is `:none`.
   config.worker = :none
 
   # The number of runs to perform. Default is `100`.
@@ -220,9 +231,6 @@ Pbt.configure do |config|
   # Whether to report exceptions in threads.
   # It's useful to suppress error logs on Ractor that reports many errors. Default is `false`.
   config.thread_report_on_exception = false
-
-  # Whether to allow RSpec expectation and matchers in Ractor. It's quite experimental! Default is `false`.
-  config.experimental_ractor_rspec_integration = false
 end
 ```
 
@@ -238,15 +246,13 @@ end
 
 One of the key features of `Pbt` is its ability to rapidly execute test cases in parallel or concurrently, using a large number of values (by default, `100`) generated by `Arbitrary`.
 
-For concurrent processing, you can specify any of the three workers—`:ractor`, `:process`, or `:thread`—using the `worker` option. Alternatively, choose `:none` for serial execution.
-
-`Pbt` supports 3 concurrency methods and 1 sequential one. You can choose one of them by setting the `worker` option.
+For concurrent processing, you can specify `:ractor` using the `worker` option. Alternatively, choose `:none` for serial execution.
 
 Be aware that the performance of each method depends on the test subject. For example, if the test subject is CPU-bound, `:ractor` may be the best choice. Otherwise, `:none` shall be the best choice for most cases. See [benchmarks](benchmark/README.md).
 
 ### Ractor
 
-`:ractor` worker is useful for test cases that are CPU-bound. But it's experimental and has some limitations as described below. If you encounter any issues due to those limitations, consider using `:process` as workers whose benchmark is the most similar to `:ractor`.
+`:ractor` worker is useful for test cases that are CPU-bound. But it's experimental and has some limitations as described below. If you encounter any issues due to those limitations, consider falling back to `:none`.
 
 ```ruby
 Pbt.assert(worker: :ractor) do
@@ -286,53 +292,9 @@ it do
 end
 ```
 
-If you're a challenger, you can enable the experimental feature to allow using RSpec expectations and matchers in Ractor. It works but it's quite experimental and could cause unexpected behaviors.
-
-Please note that this feature depends on [prism](https://ruby.github.io/prism/) gem. If you use Ruby 3.2 or prior, you need to install the gem by yourself.
-
-```ruby
-it do
-  Pbt.assert(worker: :ractor, experimental_ractor_rspec_integration: true) do
-    Pbt.property(Pbt.integer) do |n|
-      # Some RSpec expectations and matchers are available in Ractor by hack.
-      # Other features like `let`, `subject`, `before`, `after` that access out of block are still not available.
-      expect(n).to be_an(Integer)
-    end
-  end
-end
-```
-
-### Process
-
-If you'd like to run test cases that are CPU-bound and `:ractor` is not available, `:process` becomes a good choice.
-
-```ruby
-Pbt.assert(worker: :process) do
-  Pbt.property(Pbt.integer) do |n|
-    # ...
-  end
-end
-```
-
-If you want to use `:process`, you need to install the [parallel](https://github.com/grosser/parallel) gem.
-
-### Thread
-
-You may not need to run test cases with multi-threads.
-
-```ruby
-Pbt.assert(worker: :thread) do
-  Pbt.property(Pbt.integer) do |n|
-    # ...
-  end
-end
-```
-
-If you want to use `:thread`, you need to install the [parallel](https://github.com/grosser/parallel) gem.
-
 ### None
 
-For most cases, `:none` is the best choice. It runs tests sequentially (without parallelism) but most test cases finishes within a reasonable time.
+For most cases, `:none` is the best choice. It runs tests sequentially but most test cases finishes within a reasonable time.
 
 ```ruby
 Pbt.assert(worker: :none) do
@@ -351,8 +313,8 @@ Once this project finishes the following, we will release v1.0.0.
 - [x] Support shrinking
 - [x] Support multiple concurrency methods
   - [x] Ractor
-  - [x] Process
-  - [x] Thread
+  - [x] Process (dropped)
+  - [x] Thread (dropped)
   - [x] None (Run tests sequentially)
 - [x] Documentation
   - [x] Add better examples
@@ -360,11 +322,13 @@ Once this project finishes the following, we will release v1.0.0.
   - [x] Configuration
 - [x] Benchmark
 - [x] Rich report by verbose mode
-- [x] (Partially) Allow to use expectations and matchers provided by test framework in Ractor if possible.
+- [x] (Partially) Allow to use expectations and matchers provided by test framework in Ractor. (dropped)
   - It'd be so hard to pass assertions like `expect`, `assert` to a Ractor.
 - [ ] Implement frequency arbitrary
 - [ ] Statistics feature to aggregate generated values
 - [ ] Decide DSL
+- [ ] Try Fiber
+- [ ] Stateful property-based testing
 
 ## Development
 

data/benchmark/failure_simple.rb

@@ -17,26 +17,6 @@ Benchmark.ips do |x|
     # noop
   end
 
-  x.report("process") do
-    Pbt.assert(worker: :process, seed:, num_runs: 100) do
-      Pbt.property(Pbt.integer) do |x|
-        task(x)
-      end
-    end
-  rescue Pbt::PropertyFailure
-    # noop
-  end
-
-  x.report("thread") do
-    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
-      Pbt.property(Pbt.integer) do |x|
-        task(x)
-      end
-    end
-  rescue Pbt::PropertyFailure
-    # noop
-  end
-
   x.report("none") do
     Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|

data/benchmark/success_cpu_bound.rb

@@ -25,22 +25,6 @@ Benchmark.ips do |x|
     end
   end
 
-  x.report("process") do
-    Pbt.assert(worker: :process, num_runs: 100) do
-      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
-        task(x, y, z)
-      end
-    end
-  end
-
-  x.report("thread") do
-    Pbt.assert(worker: :thread, num_runs: 100) do
-      Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|
-        task(x, y, z)
-      end
-    end
-  end
-
   x.report("none") do
     Pbt.assert(worker: :none, num_runs: 100) do
       Pbt.property(Pbt.constant([a, b, c])) do |x, y, z|

data/benchmark/success_io_bound.rb

@@ -18,22 +18,6 @@ Benchmark.ips do |x|
     end
   end
 
-  x.report("process") do
-    Pbt.assert(worker: :process, seed:, num_runs: 100) do
-      Pbt.property(Pbt.ascii_string) do |str|
-        task(str)
-      end
-    end
-  end
-
-  x.report("thread") do
-    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
-      Pbt.property(Pbt.ascii_string) do |str|
-        task(str)
-      end
-    end
-  end
-
   x.report("none") do
     Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.ascii_string) do |str|

data/benchmark/success_simple.rb

@@ -14,22 +14,6 @@ Benchmark.ips do |x|
     end
   end
 
-  x.report("process") do
-    Pbt.assert(worker: :process, seed:, num_runs: 100) do
-      Pbt.property(Pbt.integer) do |x|
-        task(x)
-      end
-    end
-  end
-
-  x.report("thread") do
-    Pbt.assert(worker: :thread, seed:, num_runs: 100) do
-      Pbt.property(Pbt.integer) do |x|
-        task(x)
-      end
-    end
-  end
-
   x.report("none") do
     Pbt.assert(worker: :none, seed:, num_runs: 100) do
       Pbt.property(Pbt.integer) do |x|

data/lib/pbt/arbitrary/arbitrary_methods.rb

@@ -92,7 +92,7 @@ module Pbt
         one_of(*HEXA_CHARS)
       end
 
-      # For lowercase hexadecimal stings.
+      # For lowercase hexadecimal strings.
       #
       # @see Pbt.array
       # @param kwargs [Hash] Options for ArrayArbitrary. See `.array` for more information.

data/lib/pbt/check/configuration.rb

@@ -9,22 +9,19 @@ module Pbt
       :num_runs,
       :seed,
       :thread_report_on_exception,
-      :experimental_ractor_rspec_integration,
       keyword_init: true
     ) do
       # @param verbose [Boolean] Whether to print verbose output. Default is `false`.
-      # @param worker [Symbol] The concurrency method to use. :ractor`, `:thread`, `:process` and `:none` are supported. Default is `:none`.
+      # @param worker [Symbol] The concurrency method to use. :ractor` and `:none` are supported. Default is `:none`.
       # @param num_runs [Integer] The number of runs to perform. Default is `100`.
       # @param seed [Integer] The seed to use for random number generation. It's useful to reproduce failed test with the seed you'd pick up from failure messages. Default is a random seed.
       # @param thread_report_on_exception [Boolean] Whether to report exceptions in threads. It's useful to suppress error logs on Ractor that reports many errors. Default is `false`.
-      # @param experimental_ractor_rspec_integration [Boolean] Whether to allow RSpec expectation and matchers in Ractor. It's quite experimental! Default is `false`.
       def initialize(
         verbose: false,
         worker: :none,
         num_runs: 100,
-        seed: Random.new.seed,
-        thread_report_on_exception: false,
-        experimental_ractor_rspec_integration: false
+        seed: Random.new_seed,
+        thread_report_on_exception: false
       )
         super
       end

data/lib/pbt/check/runner_methods.rb

@@ -54,8 +54,6 @@ module Pbt
       #
       # - `:thread_report_on_exception`
       #   So many exception reports happen in Ractor and a console gets too messy. Suppress them to avoid that.
-      # - `:experimental_ractor_rspec_integration`
-      #   Allow to use Ractor with RSpec. This is an experimental feature and it's not stable.
       #
       # @param config [Hash] Configuration parameters.
       # @param property [Property]
@@ -64,21 +62,12 @@ module Pbt
         if config[:worker] == :ractor
           original_report_on_exception = Thread.report_on_exception
           Thread.report_on_exception = config[:thread_report_on_exception]
-
-          if config[:experimental_ractor_rspec_integration]
-            require "pbt/check/rspec_adapter/integration"
-            class << property
-              include Pbt::Check::RSpecAdapter::PropertyExtension
-            end
-            property.setup_rspec_integration
-          end
         end
 
         yield
       ensure
         if config[:worker] == :ractor
           Thread.report_on_exception = original_report_on_exception
-          property.teardown_rspec_integration if config[:experimental_ractor_rspec_integration]
         end
       end
 
@@ -96,10 +85,6 @@ module Pbt
             run_it_in_sequential(property, runner)
           in :ractor
             run_it_in_ractors(property, runner)
-          in :process
-            run_it_in_processes(property, runner)
-          in :thread
-            run_it_in_threads(property, runner)
           end
         end
         runner.run_execution
@@ -133,80 +118,11 @@ module Pbt
           c.ractor.take
           runner.handle_result(c)
         rescue => e
-          handle_ractor_error(e.cause, c)
+          c.exception = e.cause # Ractor error is wrapped in a Ractor::RemoteError. We need to get the cause.
           runner.handle_result(c)
           break # Ignore the rest of the cases. Just pick up the first failure.
         end
       end
-
-      def handle_ractor_error(cause, c)
-        # Ractor error is wrapped in a Ractor::RemoteError. We need to get the cause.
-        unless defined?(Pbt::Check::RSpecAdapter) && cause.is_a?(Pbt::Check::RSpecAdapter::ExpectationNotMet) # Unknown error.
-          c.exception = cause
-          return
-        end
-
-        # Convert Pbt's custom error to RSpec's error.
-        begin
-          RSpec::Expectations::ExpectationHelper.handle_failure(cause.matcher, cause.custom_message, cause.failure_message_method)
-        rescue RSpec::Expectations::ExpectationNotMetError => e # The class inherits Exception, not StandardError.
-          c.exception = e
-        end
-      end
-
-      # @param property [Property] Property to test.
-      # @param runner [RunnerIterator]
-      # @return [void]
-      def run_it_in_threads(property, runner)
-        require_parallel
-
-        Parallel.map_with_index(runner, in_threads: Parallel.processor_count) do |val, index|
-          Case.new(val:, index:).tap do |c|
-            property.run(val)
-          # Catch all exceptions including RSpec's ExpectationNotMet (It inherits Exception).
-          rescue Exception => e # standard:disable Lint/RescueException:
-            c.exception = e
-            # It's possible to break this loop here by raising `Parallel::Break`.
-            # But if it raises, we cannot fetch all cases' result. So this loop continues until the end.
-          end
-        end.each do |c|
-          runner.handle_result(c)
-          break if c.exception
-          # Ignore the rest of the cases. Just pick up the first failure.
-        end
-      end
-
-      # @param property [Property] Property to test.
-      # @param runner [RunnerIterator]
-      # @return [void]
-      def run_it_in_processes(property, runner)
-        require_parallel
-
-        Parallel.map_with_index(runner, in_processes: Parallel.processor_count) do |val, index|
-          Case.new(val:, index:).tap do |c|
-            property.run(val)
-          # Catch all exceptions including RSpec's ExpectationNotMet (It inherits Exception).
-          rescue Exception => e # standard:disable Lint/RescueException:
-            c.exception = e
-            # It's possible to break this loop here by raising `Parallel::Break`.
-            # But if it raises, we cannot fetch all cases' result. So this loop continues until the end.
-          end
-        end.each do |c|
-          runner.handle_result(c)
-          break if c.exception
-          # Ignore the rest of the cases. Just pick up the first failure.
-        end
-      end
-
-      # Load Parallel gem. If it's not installed, raise an error.
-      # @see https://github.com/grosser/parallel
-      # @raise [InvalidConfiguration]
-      def require_parallel
-        require "parallel"
-      rescue LoadError
-        raise InvalidConfiguration,
-          "Parallel gem (https://github.com/grosser/parallel) is required to use worker `:process` or `:thread`. Please add `gem 'parallel'` to your Gemfile."
-      end
     end
   end
 end

data/lib/pbt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pbt
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pbt
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - ohbarye
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-09 00:00:00.000000000 Z
+date: 2024-12-30 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -46,9 +46,6 @@ files:
 - lib/pbt/check/case.rb
 - lib/pbt/check/configuration.rb
 - lib/pbt/check/property.rb
-- lib/pbt/check/rspec_adapter/integration.rb
-- lib/pbt/check/rspec_adapter/predicate_block_inspector.rb
-- lib/pbt/check/rspec_adapter/property_extension.rb
 - lib/pbt/check/runner_iterator.rb
 - lib/pbt/check/runner_methods.rb
 - lib/pbt/check/tosser.rb
@@ -79,7 +76,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.21
 signing_key:
 specification_version: 4
 summary: Property-Based Testing tool for Ruby, utilizing Ractor for parallelizing

data/lib/pbt/check/rspec_adapter/integration.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-unless defined?(RSpec)
-  raise InvalidConfigurationError, "You configured `experimental_ractor_rspec_integration: true` but RSpec is not loaded. Please use RSpec or set the config `false`."
-end
-
-require "pbt/check/rspec_adapter/predicate_block_inspector"
-require "pbt/check/rspec_adapter/property_extension"
-
-module Pbt
-  module Check
-    # @private
-    module RSpecAdapter
-      # This custom error contains RSpec matcher and message to handle Pbt's runner.
-      # @private
-      class ExpectationNotMet < StandardError
-        attr_reader :matcher, :custom_message, :failure_message_method
-
-        def initialize(msg, matcher, custom_message, failure_message_method)
-          super(msg)
-          @matcher = matcher
-          @custom_message = custom_message
-          @failure_message_method = failure_message_method
-        end
-      end
-    end
-  end
-end
-
-# `autoload` is not allowed in Ractor but RSpec uses autoload for matchers.
-# We need to load them in advance in order to be able to use them in Ractor.
-#
-# e.g. Ractor raises... `be_a_kind_of': require by autoload on non-main Ractor is not supported (BeAKindOf) (Ractor::UnsafeError)
-RSpec::Matchers::BuiltIn.constants.each { |c| Object.const_get("RSpec::Matchers::BuiltIn::#{c}") }
-
-# TODO: preload more helpers like aggregate_failures.
-# RSpec::Expectations.constants.each { |c| Object.const_get("RSpec::Expectations::#{c}") }
-# The code above is not enough. Even if we run this code in advance, Ractor raises...
-# in `failure_notifier': can not access non-shareable objects in constant RSpec::Support::DEFAULT_FAILURE_NOTIFIER by non-main ractor. (Ractor::IsolationError)
-
-# CAUTION: This is a dirty hack! We need to override the original method to make it Ractor-safe.
-RSpec::Expectations::ExpectationHelper.singleton_class.prepend(Module.new do
-  def with_matcher(handler, matcher, message)
-    check_message(message)
-    matcher = modern_matcher_from(matcher)
-    yield matcher
-  ensure
-    # The original method is not Ractor-safe unless stopping assigning these class variables.
-    if Ractor.current == Ractor.main
-      ::RSpec::Matchers.last_expectation_handler = handler
-      ::RSpec::Matchers.last_matcher = matcher
-    end
-  end
-
-  def handle_failure(matcher, message, failure_message_method)
-    # This method is not Ractor-safe. RSpec::Support::ObjectFormatter.default_instance assigns class variables.
-    # If this method is called in non-main-Ractor, it raises a custom error and let it handle in the main Ractor.
-    if Ractor.current != Ractor.main
-      raise Pbt::Check::RSpecAdapter::ExpectationNotMet.new(nil, matcher, message, failure_message_method)
-    end
-
-    super
-  end
-end)

data/lib/pbt/check/rspec_adapter/predicate_block_inspector.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  # Use prism to get user-defined block code.
-  require "prism"
-rescue LoadError
-  raise InvalidConfiguration,
-    "Prism gem (https://github.com/grosser/parallel) is required to use worker `:rator` and `:experimental_ractor_rspec_integration`. Please add `gem 'parallel'` to your Gemfile."
-end
-
-module Pbt
-  module Check
-    module RSpecAdapter
-      # This class is used to get user-defined block code.
-      # If a user defines code like below:
-      #
-      #   Pbt.property(Pbt.integer, Pbt.integer) do |x, y|
-      #     x > 0 && y > 0
-      #   end
-      #
-      #   inspector.method_params #=> "x, y"
-      #   inspector.method_body   #=> "x > 0 && y > 0"
-      #
-      # @private
-      # @!attribute [r] method_body
-      # @!attribute [r] method_params
-      class PredicateBlockInspector < Prism::Visitor
-        attr_reader :method_body, :method_params
-
-        def initialize(line)
-          @line = line
-          @method_body = nil
-          super()
-        end
-
-        def visit_call_node(node)
-          if node.name == :property && node.block.opening_loc.start_line == @line
-            @method_params = node.block.parameters.parameters.slice
-            @method_body = node.block.body.slice
-          end
-
-          super
-        end
-      end
-    end
-  end
-end

data/lib/pbt/check/rspec_adapter/property_extension.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-module Pbt
-  module Check
-    module RSpecAdapter
-      # @private
-      module PropertyExtension
-        # Define an original class to be called in Ractor.
-        #
-        # @return [void]
-        def setup_rspec_integration
-          filepath, line = @predicate.source_location
-          basename = File.basename(filepath, ".rb")
-          @class_name = "Test" + basename.split("_").map(&:capitalize).join + line.to_s
-          @method_name = "predicate_#{basename}_#{line}"
-          define_ractor_callable_class
-        end
-
-        # Clean up an original class to be called in Ractor to avoid any persisted namespace pollution.
-        #
-        # @return [void]
-        def teardown_rspec_integration
-          RSpecAdapter.__send__(:remove_const, @class_name) if RSpecAdapter.const_defined?(@class_name)
-        end
-
-        # Run the predicate with the generated `val`.
-        # This overrides the original `Property#run_in_ractor`.
-        #
-        # @param val [Object]
-        # @return [Ractor]
-        def run_in_ractor(val)
-          Ractor.new(@class_name, @method_name, @predicate.parameters.size, val) do |class_name, method_name, param_size, val|
-            klass = RSpecAdapter.const_get(class_name)
-            if val.is_a?(Hash)
-              klass.new.send(method_name, **val)
-            elsif param_size >= 2
-              klass.new.send(method_name, *val)
-            else
-              klass.new.send(method_name, val)
-            end
-          end
-        end
-
-        private
-
-        # @return [void]
-        def define_ractor_callable_class
-          # The @method_name is invisible in the Class.new block, so we need to assign it to a local variable.
-          method_name = @method_name
-
-          inspector = extract_predicate_source_code
-
-          RSpecAdapter.const_set(@class_name, Class.new do
-            include ::RSpec::Matchers
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method_name}(#{inspector.method_params})
-              #{inspector.method_body}
-            end
-            RUBY
-          end)
-        end
-
-        # @return [PredicateBlockInspector]
-        def extract_predicate_source_code
-          filepath, line = @predicate.source_location
-          PredicateBlockInspector.new(line).tap do |inspector|
-            res = Prism.parse_file(filepath)
-            res.value.statements.accept(inspector)
-          end
-        end
-      end
-    end
-  end
-end