prop_check 0.10.4 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8f707bae1dadf800e667376a749c7d5de3f3d741d13e63118de79dfb7233fb5
-  data.tar.gz: e86ac3b096bff66cfa88c0a66b1fc8ea91dc8452ded41c417fb1452c33c2b1d7
+  metadata.gz: fb51503257a33dbe349da1b2b582be1c0fe38465bbe10fb14f610885591c9f7b
+  data.tar.gz: d357a2221e6b078c58d78826758cb22f4df3b8c34dd746001d854c505dfe2dea
 SHA512:
-  metadata.gz: e0985469e34e0b353aab0fac657a073fadfe135c03029187d3f7824ebded0bfd244122aa2ae4361b5ccad3fb05ca52162e3967e9f46a6e43674e7d7626a700f7
-  data.tar.gz: 0b0505768ea68855beaf9c8954cb973215dd392c40975e7f581e7faa9d7570c9e4fb76402227c5b0f223f96e87f72d58decfb7dffd2744897c22db3ba0959ac6
+  metadata.gz: 5d757c5c95b19cb3805ff1cc14af811fbb5e4f0cdb0cadffa581f46d33d20f2c37b8093fda66828b6ce3862b0743723ebb5afe01b183acc4bdbe6fc3f96ddb9b
+  data.tar.gz: e9288cedccdaafe609c2557a74176b9eea306fbff4aa2e9b9a4219702755efa33e53fb9f22d13f5ad0d7aa1af0dca732a1fe924d2119c43df39b71d1107be6d4

data/.tool-versions

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

data/.travis.yml

@@ -3,7 +3,7 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5.1
+  - 2.6.5
 before_install: gem install bundler -v 2.0.2
 env:
   global:

data/CHANGELOG.md

@@ -1 +1,6 @@
-- 0.8.0 New syntax that is more explicit, passng generated values to blocks as parameters.
+- 0.13.0 - Adds Generator#resize
+- 0.12.1 - Fixes shrinking when filtering bug.
+- 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/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/lib/prop_check/generator.rb

@@ -11,6 +11,7 @@ module PropCheck
     @@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.
@@ -21,10 +22,13 @@ module PropCheck
     ##
     # Given a `size` (integer) and a random number generator state `rng`,
     # generate a LazyTree.
-    def generate(size = @@default_size, rng = @@default_rng, max_consecutive_attempts = @@max_consecutive_attempts)
+    def generate(**kwargs)
+      kwargs = @@default_kwargs.merge(kwargs)
+      max_consecutive_attempts = kwargs[:max_consecutive_attempts]
+
       (0..max_consecutive_attempts).each do
-        res = @block.call(size, rng)
-        next if res == :"PropCheck.filter_me"
+        res = @block.call(**kwargs)
+        next if res.root == :"_PropCheck.filter_me"
 
         return res
       end
@@ -40,18 +44,18 @@ module PropCheck
     # 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
 
@@ -61,10 +65,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
 
     ##
@@ -73,7 +77,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|
@@ -83,11 +87,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
@@ -95,34 +99,40 @@ 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)
-        result.map do |*val|
-          proc.call(*val)
-        end
+      Generator.new do |**kwargs|
+        result = self.generate(**kwargs)
+        result.map(&proc)
       end
     end
 
     ##
     # 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
+
+    ##
+    # Resizes the generator to either grow faster or smaller than normal.
+    #
+    # `proc` takes the current size as input and is expected to return the new size.
+    # a size should always be a nonnegative integer.
+    #
+    #    >> Generators.integer.resize{}
+    def resize(&proc)
+      Generator.new do |size:, **other_kwargs|
+        new_size = proc.call(size)
+        self.generate(**other_kwargs, size: new_size)
+      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,19 +74,27 @@ 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:, **|
+        ensure_proper_size!(size)
+
         val = rng.rand(-size..size)
         LazyTree.new(val, integer_shrink(val))
       end
     end
 
+    private def ensure_proper_size!(size)
+      return if size.is_a?(Integer) && size >= 0
+
+      raise ArgumentError, "`size:` should be a nonnegative integer but got `#{size.inspect}`"
+    end
+
     ##
     # Only returns integers that are zero or larger.
     # See `integer` for more information.
@@ -193,12 +202,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 +219,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 +236,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
+        res.call(max)
+      end
     end
 
     ##
@@ -249,11 +283,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 +321,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 +347,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 +386,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 +417,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 +443,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 +528,44 @@ 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
+    #      attr_accessor :name, :age
+    #      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,12 +7,18 @@ module PropCheck
   class LazyTree
     require 'prop_check/helper'
 
-    attr_accessor :root, :children
+    include Enumerable
+
+    attr_accessor :root
     def initialize(root, children = [].lazy)
       @root = root
       @children = children
     end
 
+    def children
+      @children.reject { |child| child.root == :"_PropCheck.filter_me" }
+    end
+
     ##
     # Maps `block` eagerly over `root` and lazily over `children`, returning a new LazyTree as result.
     #
@@ -66,25 +72,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
 
     ##
@@ -129,5 +125,6 @@ module PropCheck
         end
       end
     end
+
   end
 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.4'
+  VERSION = '0.13.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.13.0
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-02 00:00:00.000000000 Z
+date: 2020-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -47,6 +47,7 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/rspec
 - bin/setup
 - lib/prop_check.rb
 - lib/prop_check/generator.rb
@@ -83,7 +84,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.