prop_check 0.10.2 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88b54994bb83cb44c77b887dfc6839e19b467bddd8a32dd7d1fe91e624261799
-  data.tar.gz: e515d1522c939cb72eed02ed9fd98b458b1944a16b6c1f50f6c6bbc7076caaa5
+  metadata.gz: 0b569736a2799a9455febcbb900042168be2f872a46657080cf1f31771e8f569
+  data.tar.gz: a97cf13cfdaaab60b16221493eab5a2de0fe7160e8d785f1ac9f5daad838e66a
 SHA512:
-  metadata.gz: 3ba9d57ffa4e1d1f7d15b9c202cf232b5a931a57ac6d2d2bba4537030400e892d3154d2ab2db9ce97f6896bf97bb3a64a3cbdba02ac9cc15a561c815e7963aa6
-  data.tar.gz: 90a2fd3a15cf2ed27fc1eb1aea4273e75c39143df861bcf0a25b456c6373a088452a7d4b5e1b52aa52a0f61b1c94b0ceceef442bf3507793417d38ad91bcb2b3
+  metadata.gz: 980bda5f214ae656a859d14041846b540341b7279cfe5fd997639d624d282811fc18968ade23822687c7b97de9363b4a3346d9dac58a0a3708585f1c02b5c45d
+  data.tar.gz: f62979c7577fae30c86b357bb50894b79c15d62603325c2496f4e341fdb93d40079873a83138f357c36c66a32089908e3e2368ac9ee579396e57f9c1714d1439

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.5
+ruby 2.7.1

data/CHANGELOG.md

@@ -1 +1,4 @@
-- 0.8.0 New syntax that is more explicit, passng generated values to blocks as parameters.
+- 0.12.0 - `PropCheck::Generators#instance`
+- 0.11.0 - Improved syntax to support Ruby 2.7 and up without deprecation warnings, full support for `#where`.
+- 0.10.0 - Some bugfixes, support for `#where`
+- 0.8.0 - New syntax that is more explicit, passng generated values to blocks as parameters.

data/README.md

@@ -24,10 +24,12 @@ Before releasing this gem on Rubygems, the following things need to be finished:
  - [x] Filtering generators. 
   - [x] Customize the max. of samples to run.
   - [x] Stop after a ludicrous amount of generator runs, to prevent malfunctioning (infinitely looping) generators from blowing up someone's computer.
- - [x] Look into customization of settings from e.g. command line arguments.
+- [x] Look into customization of settings from e.g. command line arguments.
 - [x] Good, unicode-compliant, string generators.
 - [x] Filtering generator outputs.
 - [x] Before/after/around hooks to add setup/teardown logic to be called before/after/around each time a check is run with new data.
+- [x] `#instance` generator to allow the easy creation of generators for custom datatypes.
+- [ ] A usage guide.
 
 # Nice-to-haves
  

data/lib/prop_check/generator.rb

@@ -10,6 +10,8 @@ module PropCheck
   class Generator
     @@default_size = 10
     @@default_rng = Random.new
+    @@max_consecutive_attempts = 100
+    @@default_kwargs = {size: @@default_size, rng: @@default_rng, max_consecutive_attempts: @@max_consecutive_attempts}
 
     ##
     # Being a special kind of Proc, a Generator wraps a block.
@@ -20,26 +22,38 @@ module PropCheck
     ##
     # Given a `size` (integer) and a random number generator state `rng`,
     # generate a LazyTree.
-    def generate(size = @@default_size, rng = @@default_rng)
-      @block.call(size, rng)
+    def generate(**kwargs)
+      kwargs = @@default_kwargs.merge(kwargs)
+      max_consecutive_attempts = kwargs[:max_consecutive_attempts]
+
+      (0..max_consecutive_attempts).each do
+        res = @block.call(**kwargs)
+        return res unless res.root == :"_PropCheck.filter_me"
+      end
+
+      raise Errors::GeneratorExhaustedError, """
+      Exhausted #{max_consecutive_attempts} consecutive generation attempts.
+
+      Probably too few generator results were adhering to a `where` condition.
+      """
     end
 
     ##
     # Generates a value, and only return this value
     # (drop information for shrinking)
     #
-    #   >> Generators.integer.call(1000, Random.new(42))
+    #   >> Generators.integer.call(size: 1000, rng: Random.new(42))
     #   => 126
-    def call(size = @@default_size, rng = @@default_rng)
-      generate(size, rng).root
+    def call(**kwargs)
+      generate(**@@default_kwargs.merge(kwargs)).root
     end
 
     ##
     # Returns `num_of_samples` values from calling this Generator.
     # This is mostly useful for debugging if a generator behaves as you intend it to.
-    def sample(num_of_samples = 10, size: @@default_size, rng: @@default_rng)
+    def sample(num_of_samples = 10, **kwargs)
       num_of_samples.times.map do
-        call(size, rng)
+        call(**@@default_kwargs.merge(kwargs))
       end
     end
 
@@ -49,10 +63,10 @@ module PropCheck
     #
     # Keen readers may notice this as the Monadic 'pure'/'return' implementation for Generators.
     #
-    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(100, Random.new(42))
+    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(size: 100, rng: Random.new(42))
     #   => [2, 79]
     def self.wrap(val)
-      Generator.new { |_size, _rng| LazyTree.wrap(val) }
+      Generator.new { LazyTree.wrap(val) }
     end
 
     ##
@@ -61,7 +75,7 @@ module PropCheck
     #
     # Keen readers may notice this as the Monadic 'bind' (sometimes known as '>>=') implementation for Generators.
     #
-    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(100, Random.new(42))
+    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(size: 100, rng: Random.new(42))
     #   => [2, 79]
     def bind(&generator_proc)
       # Generator.new do |size, rng|
@@ -71,11 +85,11 @@ module PropCheck
       #     inner_generator.generate(size, rng)
       #   end.flatten
       # end
-      Generator.new do |size, rng|
-        outer_result = self.generate(size, rng)
+      Generator.new do |**kwargs|
+        outer_result = self.generate(**kwargs)
         outer_result.bind do |outer_val|
           inner_generator = generator_proc.call(outer_val)
-          inner_generator.generate(size, rng)
+          inner_generator.generate(**kwargs)
         end
       end
     end
@@ -83,11 +97,11 @@ module PropCheck
     ##
     # Creates a new Generator that returns a value by running `proc` on the output of the current Generator.
     #
-    #   >> Generators.choose(32..128).map(&:chr).call(10, Random.new(42))
+    #   >> Generators.choose(32..128).map(&:chr).call(size: 10, rng: Random.new(42))
     #   => "S"
     def map(&proc)
-      Generator.new do |size, rng|
-        result = self.generate(size, rng)
+      Generator.new do |**kwargs|
+        result = self.generate(**kwargs)
         result.map(&proc)
       end
     end
@@ -95,20 +109,14 @@ module PropCheck
     ##
     # Creates a new Generator that only produces a value when the block `condition` returns a truthy value.
     def where(&condition)
-      self.map do |*result|
-        if condition.call(*result)
+      self.map do |result|
+        # if condition.call(*result)
+        if PropCheck::Helper.call_splatted(result, &condition)
           result
         else
           :"_PropCheck.filter_me"
         end
       end
-      # self.map do |*result|
-      #   if condition.call(*result)
-      #     result
-      #   else
-      #     :'_PropCheck.filter_me'
-      #   end
-      # end
     end
   end
 end

data/lib/prop_check/generators.rb

@@ -10,6 +10,7 @@ module PropCheck
   # where you want to use them.
   module Generators
     extend self
+
     ##
     # Always returns the same value, regardless of `size` or `rng` (random number generator state)
     #
@@ -59,7 +60,7 @@ module PropCheck
     #   >> r = Random.new(42); Generators.choose(0..5).sample(size: 20000, rng: r)
     #   => [3, 4, 2, 4, 4, 1, 2, 2, 2, 4]
     def choose(range)
-      Generator.new do |_size, rng|
+      Generator.new do |rng:, **|
         val = rng.rand(range)
         LazyTree.new(val, integer_shrink(val))
       end
@@ -73,14 +74,14 @@ module PropCheck
     #
     # Shrinks to integers closer to zero.
     #
-    #   >> Generators.integer.call(2, Random.new(42))
+    #   >> Generators.integer.call(size: 2, rng: Random.new(42))
     #   => 1
-    #   >> Generators.integer.call(10000, Random.new(42))
+    #   >> Generators.integer.call(size: 10000, rng: Random.new(42))
     #   => 5795
     #   >> r = Random.new(42); Generators.integer.sample(size: 20000, rng: r)
     #   => [-4205, -19140, 18158, -8716, -13735, -3150, 17194, 1962, -3977, -18315]
     def integer
-      Generator.new do |size, rng|
+      Generator.new do |size:, rng:, **|
         val = rng.rand(-size..size)
         LazyTree.new(val, integer_shrink(val))
       end
@@ -193,12 +194,12 @@ module PropCheck
     #
     # Shrinks element generators, one at a time (trying last one first).
     #
-    #   >> Generators.tuple(Generators.integer, Generators.real_float).call(10, Random.new(42))
+    #   >> Generators.tuple(Generators.integer, Generators.real_float).call(size: 10, rng: Random.new(42))
     #   => [-4, 13.0]
     def tuple(*generators)
-      Generator.new do |size, rng|
+      Generator.new do |**kwargs|
         LazyTree.zip(generators.map do |generator|
-          generator.generate(size, rng)
+          generator.generate(**kwargs)
         end)
       end
     end
@@ -210,7 +211,7 @@ module PropCheck
     #
     # Shrinks element generators.
     #
-    #    >> Generators.fixed_hash(a: Generators.integer(), b: Generators.real_float(), c: Generators.integer()).call(10, Random.new(42))
+    #    >> Generators.fixed_hash(a: Generators.integer(), b: Generators.real_float(), c: Generators.integer()).call(size: 10, rng: Random.new(42))
     #    => {:a=>-4, :b=>13.0, :c=>-3}
     def fixed_hash(hash)
       keypair_generators =
@@ -227,17 +228,42 @@ module PropCheck
     # is generated by `element_generator`.
     #
     # Shrinks to shorter arrays (with shrunken elements).
+    # Accepted keyword arguments:
+    #
+    # `empty:` When false, behaves the same as `min: 1`
+    # `min:` Ensures at least this many elements are generated. (default: 0)
+    # `max:` Ensures at most this many elements are generated. When nil, an arbitrary count is used instead. (default: nil)
+    #
     #
+    #    >> Generators.array(Generators.positive_integer).sample(5, size: 1, rng: Random.new(42))
+    #    =>  [[2], [2], [2], [1], [2]]
     #    >> Generators.array(Generators.positive_integer).sample(5, size: 10, rng: Random.new(42))
     #    => [[10, 5, 1, 4], [5, 9, 1, 1, 11, 8, 4, 9, 11, 10], [6], [11, 11, 2, 2, 7, 2, 6, 5, 5], [2, 10, 9, 7, 9, 5, 11, 3]]
-    def array(element_generator)
-      nonnegative_integer.bind do |generator|
-        generators = (0...generator).map do
+    #
+    #    >> Generators.array(Generators.positive_integer, empty: true).sample(5, size: 1, rng: Random.new(1))
+    #    =>  [[], [2], [], [], [2]]
+    #    >> Generators.array(Generators.positive_integer, empty: false).sample(5, size: 1, rng: Random.new(1))
+    #    =>  [[2], [1], [2], [1], [1]]
+
+
+    def array(element_generator, min: 0, max: nil, empty: true)
+      min = 1 if min.zero? && !empty
+
+      res = proc do |count|
+        count = min + 1 if count < min
+        count += 1 if count == min && min != 0
+        generators = (min...count).map do
           element_generator.clone
         end
 
         tuple(*generators)
       end
+
+      if max.nil?
+        nonnegative_integer.bind(&res)
+      else
+        proc.call(max)
+      end
     end
 
     ##
@@ -249,11 +275,22 @@ module PropCheck
     #
     #    >> Generators.hash(Generators.printable_ascii_string, Generators.positive_integer).sample(5, size: 3, rng: Random.new(42))
     #    => [{""=>2, "g\\4"=>4, "rv"=>2}, {"7"=>2}, {"!"=>1, "E!"=>1}, {"kY5"=>2}, {}]
-    def hash(key_generator, value_generator)
-      array(tuple(key_generator, value_generator))
-        .map(&:to_h)
+    def hash(*args, **kwargs)
+      if args.length == 2
+        hash_of(*args, **kwargs)
+      else
+        super
+      end
     end
 
+    ##
+    #
+    # Alias for `#hash` that does not conflict with a possibly overriden `Object#hash`.
+    #
+    def hash_of(key_generator, value_generator, **kwargs)
+      array(tuple(key_generator, value_generator), **kwargs)
+        .map(&:to_h)
+    end
 
     @alphanumeric_chars = [('a'..'z'), ('A'..'Z'), ('0'..'9')].flat_map(&:to_a).freeze
     ##
@@ -276,8 +313,8 @@ module PropCheck
     #
     #    >> Generators.alphanumeric_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["ZCoQ", "8uM", "wkkx0JNx", "v0bxRDLb", "Gl5v8RyWA6"]
-    def alphanumeric_string
-      array(alphanumeric_char).map(&:join)
+    def alphanumeric_string(**kwargs)
+      array(alphanumeric_char, **kwargs).map(&:join)
     end
 
     @printable_ascii_chars = (' '..'~').to_a.freeze
@@ -302,8 +339,8 @@ module PropCheck
     #
     #    >> Generators.printable_ascii_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["S|.g", "rvjjw7\"5T!", "=", "!_[4@", "Y"]
-    def printable_ascii_string
-      array(printable_ascii_char).map(&:join)
+    def printable_ascii_string(**kwargs)
+      array(printable_ascii_char, **kwargs).map(&:join)
     end
 
     @ascii_chars = [
@@ -341,8 +378,8 @@ module PropCheck
     #
     #    >> Generators.ascii_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["S|.g", "drvjjw\b\a7\"", "!w=E!_[4@k", "x", "zZI{[o"]
-    def ascii_string
-      array(ascii_char).map(&:join)
+    def ascii_string(**kwargs)
+      array(ascii_char, **kwargs).map(&:join)
     end
 
     @printable_chars = [
@@ -372,8 +409,8 @@ module PropCheck
     #
     #    >> Generators.printable_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["", "Ȍ", "𐁂", "Ȕ", ""]
-    def printable_string
-      array(printable_char).map(&:join)
+    def printable_string(**kwargs)
+      array(printable_char, **kwargs).map(&:join)
     end
 
     ##
@@ -398,8 +435,8 @@ module PropCheck
     #
     #    >> Generators.string.sample(5, size: 10, rng: Random.new(42))
     #    => ["\u{A3DB3}𠍜\u{3F46A}\u{1AEBC}", "􍙦𡡹󴇒\u{DED74}𪱣\u{43E97}ꂂ\u{50695}􏴴\u{C0301}", "\u{4FD9D}", "\u{C14BF}\u{193BB}𭇋󱣼\u{76B58}", "𦐺\u{9FDDB}\u{80ABB}\u{9E3CF}𐂽\u{14AAE}"]
-    def string
-      array(char).map(&:join)
+    def string(**kwargs)
+      array(char, **kwargs).map(&:join)
     end
 
     ##
@@ -483,5 +520,43 @@ module PropCheck
     def nillable(other_generator)
       frequency(9 => other_generator, 1 => constant(nil))
     end
+
+    ##
+    # Generates an instance of `klass`
+    # using `args` and/or `kwargs`
+    # as generators for the arguments that are passed to `klass.new`
+    #
+    # ## Example:
+    #
+    # Given a class like this:
+    #
+    #
+    #    class User
+    #      def initialize(name: , age: )
+    #        @name = name
+    #        @age = age
+    #      end
+    #
+    #      def inspect
+    #        "<User name: #{@name.inspect}, age: #{@age.inspect}>"
+    #      end
+    #    end
+    #
+    #   >> user_gen = Generators.instance(User, name: Generators.printable_ascii_string, age: Generators.nonnegative_integer)
+    #   >> user_gen.sample(3, rng: Random.new(42)).inspect
+    #   => "[<User name: \"S|.g\", age: 10>, <User name: \"rvjj\", age: 10>, <User name: \"7\\\"5T!w=\", age: 5>]"
+    def instance(klass, *args, **kwargs)
+      tuple(*args).bind do |vals|
+        fixed_hash(**kwargs).map do |kwvals|
+          if kwvals == {}
+            klass.new(*vals)
+          elsif vals == []
+            klass.new(**kwvals)
+          else
+            klass.new(*vals, **kwvals)
+          end
+        end
+      end
+    end
   end
 end

data/lib/prop_check/helper.rb

@@ -31,5 +31,19 @@ module PropCheck
     def lazy_append(this_enumerator, other_enumerator)
       [this_enumerator, other_enumerator].lazy.flat_map(&:lazy)
     end
+
+    def call_splatted(val, &block)
+      case val
+      when Hash
+        block.call(**val)
+      else
+        block.call(val)
+      end
+      # if kwval != {}
+      #   block.call(**kwval)
+      # else
+      #   block.call(*val)
+      # end
+    end
   end
 end

data/lib/prop_check/lazy_tree.rb

@@ -7,6 +7,8 @@ module PropCheck
   class LazyTree
     require 'prop_check/helper'
 
+    include Enumerable
+
     attr_accessor :root, :children
     def initialize(root, children = [].lazy)
       @root = root
@@ -66,25 +68,15 @@ module PropCheck
     #   >> LazyTree.new(1, [LazyTree.new(2, [LazyTree.new(3)]), LazyTree.new(4)]).each.force
     #   => [1, 4, 2, 3]
     def each(&block)
-      squish = lambda do |tree, list|
-        new_children = tree.children.reduce(list) { |acc, elem| squish.call(elem, acc) }
-        PropCheck::Helper.lazy_append([tree.root], new_children)
-      end
-
-      squish
-        .call(self, [])
+      self.to_enum(:each) unless block_given?
 
-      # base = [root]
-      # recursive = children.map(&:each)
-      # res = PropCheck::Helper.lazy_append(base, recursive)
-
-      # return res.each(&block) if block_given?
-
-      # res
+      squish([])
+      .each(&block)
+    end
 
-      # res = [[root], children.flat_map(&:each)].lazy.flat_map(&:lazy)
-      # res = res.map(&block) if block_given?
-      # res
+    protected def squish(arr)
+      new_children = self.children.reduce(arr) { |acc, elem| elem.squish(acc) }
+      PropCheck::Helper.lazy_append([self.root], new_children)
     end
 
     ##

data/lib/prop_check/property.rb

@@ -35,9 +35,9 @@ module PropCheck
     # a Property object is returned, which you can call the other instance methods
     # of this class on before finally passing a block to it using `#check`.
     # (so `forall(Generators.integer) do |val| ... end` and forall(Generators.integer).check do |val| ... end` are the same)
-    def self.forall(*bindings, &block)
+    def self.forall(*bindings, **kwbindings, &block)
 
-      property = new(*bindings)
+      property = new(*bindings, **kwbindings)
 
       return property.check(&block) if block_given?
 
@@ -66,8 +66,9 @@ module PropCheck
     def initialize(*bindings, **kwbindings)
       raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
 
-      @bindings = bindings
-      @kwbindings = kwbindings
+      # @bindings = bindings
+      # @kwbindings = kwbindings
+      @gen = gen_from_bindings(bindings, kwbindings)
       @condition = proc { true }
       @config = self.class.configuration
       @hooks = PropCheck::Hooks.new
@@ -106,14 +107,17 @@ module PropCheck
     # you might encounter a GeneratorExhaustedError.
     # Only filter if you have few inputs to reject. Otherwise, improve your generators.
     def where(&condition)
-      original_condition = @condition.dup
-      @condition = proc do |*args|
-        original_condition.call(*args) && condition.call(*args)
-      end
+      # original_condition = @condition.dup
+      # @condition = proc do |val|
+      #   call_splatted(val, &original_condition) && call_splatted(val, &condition)
+      #   # original_condition.call(val) && condition.call(val)
+      # end
+      @gen = @gen.where(&condition)
 
       self
     end
 
+
     ##
     # Calls `hook` before each time a check is run with new data.
     #
@@ -155,21 +159,11 @@ module PropCheck
     ##
     # Checks the property (after settings have been altered using the other instance methods in this class.)
     def check(&block)
-      gens =
-        if @kwbindings != {}
-          kwbinding_generator = PropCheck::Generators.fixed_hash(**@kwbindings)
-          @bindings + [kwbinding_generator]
-        else
-          @bindings
-        end
-      binding_generator = PropCheck::Generators.tuple(*gens)
-      # binding_generator = PropCheck::Generators.fixed_hash(**@kwbindings)
-
       n_runs = 0
       n_successful = 0
 
       # Loop stops at first exception
-      attempts_enum(binding_generator).each do |generator_result|
+      attempts_enum(@gen).each do |generator_result|
         n_runs += 1
         check_attempt(generator_result, n_successful, &block)
         n_successful += 1
@@ -178,6 +172,25 @@ module PropCheck
       ensure_not_exhausted!(n_runs)
     end
 
+    private def gen_from_bindings(bindings, kwbindings)
+      if bindings == [] && kwbindings != {}
+        PropCheck::Generators.fixed_hash(**kwbindings)
+      elsif bindings != [] && kwbindings == {}
+        if bindings.size == 1
+          bindings.first
+        else
+          PropCheck::Generators.tuple(*bindings)
+        end
+      else
+        raise ArgumentError,
+              'Attempted to use both normal and keyword bindings at the same time.
+This is not supported because of the separation of positional and keyword arguments
+(the old behaviour is deprecated in Ruby 2.7 and will be removed in 3.0)
+c.f. https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+     '
+      end
+    end
+
     private def ensure_not_exhausted!(n_runs)
       return if n_runs >= @config.n_runs
 
@@ -196,7 +209,7 @@ module PropCheck
     end
 
     private def check_attempt(generator_result, n_successful, &block)
-      block.call(*generator_result.root)
+      PropCheck::Helper.call_splatted(generator_result.root, &block)
 
     # immediately stop (without shrinnking) for when the app is asked
     # to close by outside intervention
@@ -236,9 +249,7 @@ module PropCheck
       size = 1
       (0...@config.max_generate_attempts)
         .lazy
-        .map { binding_generator.generate(size, rng) }
-        .reject { |val| val.root.any? { |elem| elem == :"_PropCheck.filter_me" }}
-        .select { |val| @condition.call(*val.root) }
+        .map { binding_generator.generate(size: size, rng: rng, max_consecutive_attempts: @config.max_consecutive_attempts) }
         .map do |result|
           size += 1
 

data/lib/prop_check/property/configuration.rb

@@ -1,8 +1,20 @@
 module PropCheck
   class Property
-    Configuration = Struct.new(:verbose, :n_runs, :max_generate_attempts, :max_shrink_steps, keyword_init: true) do
+    Configuration = Struct.new(
+      :verbose,
+      :n_runs,
+      :max_generate_attempts,
+      :max_shrink_steps,
+      :max_consecutive_attempts,
+      keyword_init: true) do
 
-      def initialize(verbose: false, n_runs: 1_000, max_generate_attempts: 10_000, max_shrink_steps: 10_000)
+      def initialize(
+            verbose: false,
+            n_runs: 1_000,
+            max_generate_attempts: 10_000,
+            max_shrink_steps: 10_000,
+            max_consecutive_attempts: 30
+          )
         super
       end
 

data/lib/prop_check/property/shrinker.rb

@@ -1,3 +1,4 @@
+require 'prop_check/helper'
 class PropCheck::Property::Shrinker
   def initialize(bindings_tree, io, hooks, config)
     @problem_child = bindings_tree
@@ -62,7 +63,7 @@ class PropCheck::Property::Shrinker
 
   private def safe_call_block(sibling, &block)
     begin
-      block.call(*sibling.root)
+      PropCheck::Helper.call_splatted(sibling.root, &block)
     # It is correct that we want to rescue _all_ Exceptions
     # not only 'StandardError's
     rescue Exception => e

data/lib/prop_check/version.rb

@@ -1,3 +1,3 @@
 module PropCheck
-  VERSION = '0.10.2'
+  VERSION = '0.12.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.12.0
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
@@ -83,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: PropCheck allows you to do property-based testing, including shrinking.