prop_check 0.11.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6938e33edff09860d467d560675d04173ac8f44c487f65f22a4253bcad01a465
-  data.tar.gz: 1ed4f6b097d008461e251f285ad52fcd32dfce27cc306862b250cea45e0b954a
+  metadata.gz: 013ca5101f31799feb0c86533c4100a781c451f937d6d8497a30476073e27e4b
+  data.tar.gz: f592ec086ca3018cfca1016baa1690619a5783274f02c910eb2ad03e5861a53d
 SHA512:
-  metadata.gz: e8d7498c00b09f17ec90fced0b130158e1919270837bad1af82ca7f4140f8904816c377cdd3489aea38d6ef36b911a128a92ca956c598daf9f0f88654ca4ac64
-  data.tar.gz: b05e4c9364808468af3c5b9807cc8cc8e036a780e449efd0468f7b577853bd3a286371a3312073c0cf5952c5debb12dd6b13ad2d3e8d0fed0952839db680757c
+  metadata.gz: f49b2514fe4e179013bd8c4a4683c1210b65d6852901156c6c5373f26305343fa4cae40860f13386a8f1fda33406927bf20a357f88cd5b99936318410837ba00
+  data.tar.gz: 261b980fb68c2d1af8baccb09919a838f91c1f6ae33f8c8a79923b2cb50490e4406e848ffbf6a75361d13d33719907a3342b4a7eed88ebdf37d1bdd8cd981ee4

data/.rubocop.yml

@@ -1,3 +1,5 @@
+AllCops:
+  TargetRubyVersion: 2.7
 Metrics/LineLength:
   Max: 120
 Style/AccessModifierDeclarations:

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,7 @@
-- 0.8.0 New syntax that is more explicit, passng generated values to blocks as parameters.
+- 0.14.0 - Adds `uniq: true` option to `Generators.array`. Makes `PropCheck::Property` an immutable object that returns copies that have changes whenever reconfiguring, allowing re-usable configuration.
+- 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,11 +99,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
@@ -108,19 +112,27 @@ 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)
+        # 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

@@ -9,7 +9,8 @@ module PropCheck
   # Use this module by including it in the class (e.g. in your test suite)
   # where you want to use them.
   module Generators
-    extend self
+    module_function
+
     ##
     # 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.
@@ -137,7 +146,7 @@ module PropCheck
       end
     end
 
-    @special_floats = [Float::NAN, Float::INFINITY, -Float::INFINITY, Float::MAX, Float::MIN, 0.0.next_float, 0.0.prev_float]
+    @@special_floats = [Float::NAN, Float::INFINITY, -Float::INFINITY, Float::MAX, Float::MIN, 0.0.next_float, 0.0.prev_float]
     ##
     # Generates floating-point numbers
     # Will generate NaN, Infinity, -Infinity,
@@ -150,7 +159,7 @@ module PropCheck
     #    >> Generators.float().sample(10, size: 10, rng: Random.new(42))
     #    => [4.0, 9.555555555555555, 0.0, -Float::INFINITY, 5.5, -5.818181818181818, 1.1428571428571428, 0.0, 8.0, 7.857142857142858]
     def float
-      frequency(99 => real_float, 1 => one_of(*@special_floats.map(&method(:constant))))
+      frequency(99 => real_float, 1 => one_of(*@@special_floats.map(&method(:constant))))
     end
 
     ##
@@ -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 =
@@ -232,6 +241,12 @@ module PropCheck
     # `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)
+    # `uniq:` When `true`, ensures that all elements in the array are unique.
+    #         When given a proc, uses the result of this proc to check for uniqueness.
+    #         (matching the behaviour of `Array#uniq`)
+    #         If it is not possible to generate another unique value after the configured `max_consecutive_attempts`
+    #         an `PropCheck::Errors::GeneratorExhaustedError` will be raised.
+    #         (default: `false`)
     #
     #
     #    >> Generators.array(Generators.positive_integer).sample(5, size: 1, rng: Random.new(42))
@@ -243,28 +258,70 @@ module PropCheck
     #    =>  [[], [2], [], [], [2]]
     #    >> Generators.array(Generators.positive_integer, empty: false).sample(5, size: 1, rng: Random.new(1))
     #    =>  [[2], [1], [2], [1], [1]]
+    #
+    #    >> Generators.array(Generators.boolean, uniq: true).sample(5, rng: Random.new(1))
+    #    => [[true, false], [false, true], [true, false], [false, true], [false, true]]
 
-
-    def array(element_generator, min: 0, max: nil, empty: true)
+    def array(element_generator, min: 0, max: nil, empty: true, uniq: false)
       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
+      uniq = proc { |x| x } if uniq == true
 
       if max.nil?
-        nonnegative_integer.bind(&res)
+        nonnegative_integer.bind { |count| make_array(element_generator, min, count, uniq) }
       else
-        proc.call(max)
+        make_array(element_generator, min, max, uniq)
       end
     end
 
+    private def make_array(element_generator, min, count, uniq)
+      amount = min if count < min
+      amount = min if count == min && min != 0
+      amount ||= (count - min)
+
+      # Simple, optimized implementation:
+      return make_array_simple(element_generator, amount) unless uniq
+
+      # More complex implementation that filters duplicates
+      make_array_uniq(element_generator, min, amount, uniq)
+    end
+
+    private def make_array_simple(element_generator, amount)
+      generators = amount.times.map do
+        element_generator.clone
+      end
+
+      tuple(*generators)
+    end
+
+    private def make_array_uniq(element_generator, min, amount, uniq_fun)
+      Generator.new do |**kwargs|
+        arr = []
+        uniques = Set.new
+        count = 0
+        (0..).lazy.map do
+          elem = element_generator.clone.generate(**kwargs)
+          if uniques.add?(uniq_fun.call(elem.root))
+            arr.push(elem)
+            count = 0
+          else
+            count += 1
+          end
+
+          if count > kwargs[:max_consecutive_attempts]
+            if arr.size >= min
+              # Give up and return shorter array in this case
+              amount = min
+            else
+              raise Errors::GeneratorExhaustedError, "Too many consecutive elements filtered by 'uniq:'."
+            end
+          end
+        end
+        .take_while { arr.size < amount }
+        .force
+
+        LazyTree.zip(arr).map { |array| array.uniq(&uniq_fun) }
+      end
+    end
 
     ##
     # Generates a hash of key->values,
@@ -275,13 +332,24 @@ 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, **kwargs)
+    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
+    @@alphanumeric_chars = [('a'..'z'), ('A'..'Z'), ('0'..'9')].flat_map(&:to_a).freeze
     ##
     # Generates a single-character string
     # containing one of a..z, A..Z, 0..9
@@ -291,7 +359,7 @@ module PropCheck
     #    >> Generators.alphanumeric_char.sample(5, size: 10, rng: Random.new(42))
     #    => ["M", "Z", "C", "o", "Q"]
     def alphanumeric_char
-      one_of(*@alphanumeric_chars.map(&method(:constant)))
+      one_of(*@@alphanumeric_chars.map(&method(:constant)))
     end
 
     ##
@@ -302,11 +370,13 @@ module PropCheck
     #
     #    >> Generators.alphanumeric_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["ZCoQ", "8uM", "wkkx0JNx", "v0bxRDLb", "Gl5v8RyWA6"]
+    #
+    # Accepts the same options as `array`
     def alphanumeric_string(**kwargs)
       array(alphanumeric_char, **kwargs).map(&:join)
     end
 
-    @printable_ascii_chars = (' '..'~').to_a.freeze
+    @@printable_ascii_chars = (' '..'~').to_a.freeze
 
     ##
     # Generates a single-character string
@@ -317,7 +387,7 @@ module PropCheck
     #   >> Generators.printable_ascii_char.sample(size: 10, rng: Random.new(42))
     #   => ["S", "|", ".", "g", "\\", "4", "r", "v", "j", "j"]
     def printable_ascii_char
-      one_of(*@printable_ascii_chars.map(&method(:constant)))
+      one_of(*@@printable_ascii_chars.map(&method(:constant)))
     end
 
     ##
@@ -328,12 +398,14 @@ module PropCheck
     #
     #    >> Generators.printable_ascii_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["S|.g", "rvjjw7\"5T!", "=", "!_[4@", "Y"]
+    #
+    # Accepts the same options as `array`
     def printable_ascii_string(**kwargs)
       array(printable_ascii_char, **kwargs).map(&:join)
     end
 
-    @ascii_chars = [
-      @printable_ascii_chars,
+    @@ascii_chars = [
+      @@printable_ascii_chars,
       [
         "\n",
         "\r",
@@ -356,7 +428,7 @@ module PropCheck
     #    >> Generators.ascii_char.sample(size: 10, rng: Random.new(42))
     #    => ["d", "S", "|", ".", "g", "\\", "4", "d", "r", "v"]
     def ascii_char
-      one_of(*@ascii_chars.map(&method(:constant)))
+      one_of(*@@ascii_chars.map(&method(:constant)))
     end
 
     ##
@@ -367,12 +439,14 @@ 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"]
+    #
+    # Accepts the same options as `array`
     def ascii_string(**kwargs)
       array(ascii_char, **kwargs).map(&:join)
     end
 
-    @printable_chars = [
-      @ascii_chars,
+    @@printable_chars = [
+      @@ascii_chars,
       "\u{A0}".."\u{D7FF}",
       "\u{E000}".."\u{FFFD}",
       "\u{10000}".."\u{10FFFF}"
@@ -387,7 +461,7 @@ module PropCheck
     #    >> Generators.printable_char.sample(size: 10, rng: Random.new(42))
     #    => ["吏", "", "", "", "", "", "", "", "", "Ȍ"]
     def printable_char
-      one_of(*@printable_chars.map(&method(:constant)))
+      one_of(*@@printable_chars.map(&method(:constant)))
     end
 
     ##
@@ -398,6 +472,8 @@ module PropCheck
     #
     #    >> Generators.printable_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["", "Ȍ", "𐁂", "Ȕ", ""]
+    #
+    # Accepts the same options as `array`
     def printable_string(**kwargs)
       array(printable_char, **kwargs).map(&:join)
     end
@@ -424,6 +500,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}"]
+    #
+    # Accepts the same options as `array`
     def string(**kwargs)
       array(char, **kwargs).map(&:join)
     end
@@ -509,5 +587,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/hooks.rb

@@ -19,10 +19,11 @@
 # wrapping the elements of an enumerable with hooks.
 class PropCheck::Hooks
   # attr_reader :before, :after, :around
-  def initialize()
-    @before = proc {}
-    @after = proc {}
-    @around = proc { |*args, &block| block.call(*args) }
+  def initialize(before: proc {}, after: proc {}, around: proc { |*args, &block| block.call(*args) })
+    @before = before
+    @after = after
+    @around = around
+    freeze
   end
 
   def wrap_enum(enumerable)
@@ -59,34 +60,40 @@ class PropCheck::Hooks
   # Adds `hook` to the `before` proc.
   # It is called after earlier-added `before` procs.
   def add_before(&hook)
-    old_before = @before
-    @before = proc {
-      old_before.call
+    # old_before = @before
+    new_before = proc {
+      @before.call
       hook.call
     }
+    # self
+    self.class.new(before: new_before, after: @after, around: @around)
   end
 
   ##
   # Adds `hook` to the `after` proc.
   # It is called before earlier-added `after` procs.
   def add_after(&hook)
-    old_after = @after
-    @after = proc {
+    # old_after = @after
+    new_after = proc {
       hook.call
-      old_after.call
+      @after.call
     }
+    # self
+    self.class.new(before: @before, after: new_after, around: @around)
   end
 
   ##
   # Adds `hook` to the `around` proc.
   # It is called _inside_ earlier-added `around` procs.
   def add_around(&hook)
-    old_around = @around
-    @around = proc do |&block|
-      old_around.call do |*args|
+    # old_around = @around
+    new_around = proc do |&block|
+      @around.call do |*args|
         hook.call(*args, &block)
       end
     end
+    # self
+    self.class.new(before: @before, after: @after, around: new_around)
   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

@@ -7,9 +7,15 @@ require 'prop_check/property/shrinker'
 require 'prop_check/hooks'
 module PropCheck
   ##
-  # Run properties
+  # Create and run property-checks.
+  #
+  # For simple usage, see `.forall`.
+  #
+  # For advanced usage, call `PropCheck::Property.new(...)` and then configure it to your liking
+  # using e.g. `#with_config`, `#before`, `#after`, `#around` etc.
+  # Each of these methods will return a new `Property`, so earlier properties are not mutated.
+  # This allows you to re-use configuration and hooks between multiple tests.
   class Property
-
     ##
     # Main entry-point to create (and possibly immediately run) a property-test.
     #
@@ -35,9 +41,8 @@ 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)
-
-      property = new(*bindings)
+    def self.forall(*bindings, **kwbindings, &block)
+      property = new(*bindings, **kwbindings)
 
       return property.check(&block) if block_given?
 
@@ -61,18 +66,25 @@ module PropCheck
       yield(configuration)
     end
 
-    attr_reader :bindings, :condition
-
     def initialize(*bindings, **kwbindings)
-      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
-
-      @bindings = bindings
-      @kwbindings = kwbindings
-      @condition = proc { true }
       @config = self.class.configuration
       @hooks = PropCheck::Hooks.new
+
+      @gen = gen_from_bindings(bindings, kwbindings) unless bindings.empty? && kwbindings.empty?
+      freeze
     end
 
+    # [:condition, :config, :hooks, :gen].each do |symbol|
+    #   define_method(symbol) do
+    #     self.instance_variable_get("@#{symbol}")
+    #   end
+
+    #   protected define_method("#{symbol}=") do |value|
+    #     duplicate = self.dup
+    #     duplicate.instance_variable_set("@#{symbol}", value)
+    #     duplicate
+    #   end
+
     ##
     # Returns the configuration of this property
     # for introspection.
@@ -90,11 +102,22 @@ module PropCheck
     # you can immediately pass a block to this method.
     # (so `forall(a: Generators.integer).with_config(verbose: true) do ... end` is the same as `forall(a: Generators.integer).with_config(verbose: true).check do ... end`)
     def with_config(**config, &block)
-      @config = @config.merge(config)
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@config, @config.merge(config))
+      duplicate.freeze
+
+      return duplicate.check(&block) if block_given?
 
-      return self.check(&block) if block_given?
+      duplicate
+    end
+
+    def with_bindings(*bindings, **kwbindings)
+      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
 
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@gen, gen_from_bindings(bindings, kwbindings))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -106,22 +129,25 @@ 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
+      raise ArgumentError, 'No generator bindings specified! #where should be called after `#forall` or `#with_bindings`.' unless @gen
 
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@gen, @gen.where(&condition))
+      duplicate.freeze
+      duplicate
     end
 
+
     ##
     # Calls `hook` before each time a check is run with new data.
     #
     # This is useful to add setup logic
     # When called multiple times, earlier-added hooks will be called _before_ `hook` is called.
     def before(&hook)
-      @hooks.add_before(&hook)
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_before(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -130,8 +156,10 @@ module PropCheck
     # This is useful to add teardown logic
     # When called multiple times, earlier-added hooks will be called _after_ `hook` is called.
     def after(&hook)
-      @hooks.add_after(&hook)
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_after(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -148,28 +176,20 @@ module PropCheck
     # it is possible for the code after `yield` not to be called.
     # So make sure that cleanup logic is wrapped with the `ensure` keyword.
     def around(&hook)
-      @hooks.add_around(&hook)
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_around(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##
     # 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 +198,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 +235,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
@@ -225,6 +264,8 @@ module PropCheck
     end
 
     private def attempts_enum(binding_generator)
+      ap @hooks
+
         @hooks
         .wrap_enum(raw_attempts_enum(binding_generator))
         .lazy
@@ -236,9 +277,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: 100,
+            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.11.0'
+  VERSION = '0.14.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.14.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-09 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.