prop_check 0.7.1 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97011ef3b26afe799c5490e6de90bd9be9b0a97b1a028d2226dee5e333db692d
-  data.tar.gz: 36c5308c6da7a232c407fb8034528cabb21ba3f9c5a19076bc7265eea98d9b35
+  metadata.gz: 88b54994bb83cb44c77b887dfc6839e19b467bddd8a32dd7d1fe91e624261799
+  data.tar.gz: e515d1522c939cb72eed02ed9fd98b458b1944a16b6c1f50f6c6bbc7076caaa5
 SHA512:
-  metadata.gz: ac484a895221b1d8e7ab5a64c1282641526a310206e0ca5de46610b4d9fc02cf693c8af77a32ad026f610947f20609f3a09ea5833f7d97822dd958da536005c9
-  data.tar.gz: 367b87d861eb5fcd36dc4ffb0698bad05c6a3805595cf4e1508e276e755241dc415ff5e6f080121608200a4f8766e7ad0992c610a4af963193e4644e62c2b625
+  metadata.gz: 3ba9d57ffa4e1d1f7d15b9c202cf232b5a931a57ac6d2d2bba4537030400e892d3154d2ab2db9ce97f6896bf97bb3a64a3cbdba02ac9cc15a561c815e7963aa6
+  data.tar.gz: 90a2fd3a15cf2ed27fc1eb1aea4273e75c39143df861bcf0a25b456c6373a088452a7d4b5e1b52aa52a0f61b1c94b0ceceef442bf3507793417d38ad91bcb2b3

data/.gitignore

@@ -11,4 +11,5 @@
 .rspec_status
 
 # .gem version files
-*.gem
+*.gem
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1 @@
+- 0.8.0 New syntax that is more explicit, passng generated values to blocks as parameters.

data/Gemfile

@@ -3,6 +3,11 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in prop_check.gemspec
 gemspec
 
-gem 'simplecov', require: false, group: :test
-gem 'doctest-rspec', require: false, group: :test
-gem 'awesome_print', require: true
+gem "bundler", "~> 2.0"
+
+group :test do
+  gem "rake", "~> 12.3", require: false
+  gem "rspec", "~> 3.0", require: false
+  gem "doctest-rspec", require: false
+  gem "simplecov", require: false
+end

data/README.md

@@ -14,7 +14,7 @@ It features:
 - Shrinking to a minimal counter-example on failure.
 
 
-## TODOs before release
+## TODOs before stable release
 
 Before releasing this gem on Rubygems, the following things need to be finished:
 
@@ -27,10 +27,11 @@ Before releasing this gem on Rubygems, the following things need to be finished:
  - [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.
 
 # Nice-to-haves
  
-- [ ] Basic integration with RSpec. See also https://groups.google.com/forum/#!msg/rspec/U-LmL0OnO-Y/iW_Jcd6JBAAJ for progress on this.
+- [x] Basic integration with RSpec. See also https://groups.google.com/forum/#!msg/rspec/U-LmL0OnO-Y/iW_Jcd6JBAAJ for progress on this.
  - [ ] `aggregate` , `resize` and similar generator-modifying calls (c.f. PropEr's variants of these) which will help with introspection/metrics.
  - [ ] Integration with other Ruby test frameworks.
  - Stateful property testing. If implemented at some point, will probably happen in a separate add-on library.
@@ -66,8 +67,9 @@ _(to be precise: a method on the execution context is defined which returns the
 Raise an exception from the block if there is a problem. If there is no problem, just return normally.
 
 ```ruby
+include PropCheck::Generators
 # testing that Enumerable#sort sorts in ascending order
-PropCheck.forall(numbers: array(integer())) do
+PropCheck.forall(array(integer)) do |numbers|
   sorted_numbers = numbers.sort
   
   # Check that no number is smaller than the previous number
@@ -77,6 +79,64 @@ PropCheck.forall(numbers: array(integer())) do
 end
 ```
 
+
+Here is another example, using it inside a test case.
+Here we check if `naive_average` indeed always returns an integer for all arrays of numbers we can pass it:
+
+```ruby
+# Somewhere you have this function definition:
+def naive_average(array)
+  array.sum / array.length
+end
+```
+```ruby
+# And then in a test case:
+include PropCheck::Generators
+PropCheck.forall(numbers: array(integer)) do |numbers:|
+  result = naive_average(numbers)
+  unless result.is_a?(Integer) do
+    raise "Expected the average to be an integer!"
+  end
+end
+
+# Or if you e.g. are using RSpec:
+describe "#naive_average" do
+  include PropCheck
+  include PropCheck::Generators
+
+  it "returns an integer for any input" do
+    forall(numbers: array(integer)) do |numbers:|
+      result = naive_average(numbers)      
+      expect(result).to be_a(Integer)
+    end
+  end
+end
+```
+
+When running this particular example PropCheck very quickly finds out that we have made a programming mistake:
+
+```ruby
+ZeroDivisionError: 
+(after 6 successful property test runs)
+Failed on: 
+`{
+    :numbers => []
+}`
+
+Exception message:
+---
+divided by 0
+---
+
+(shrinking impossible)
+---
+```
+
+Clearly we forgot to handle the case of an empty array being passed to the function.
+This is a good example of the kind of conceptual bugs that PropCheck (and property-based testing in general)
+are able to check for.
+
+
 #### Shrinking
 
 When a failure is found, PropCheck will re-run the block given to `forall` to test
@@ -88,8 +148,8 @@ PropCheck will see if the failure still happens with `x = 50`.
 If it does , it will try `x = 25`. If not, it will try `x = 75`, and so on.
 
 This means if something only goes wrong for `x = 2`, the program will try:
-- `x = 100`(fails),`
-- x = 50`(fails), 
+- `x = 100`(fails),
+- `x = 50`(fails), 
 - `x = 25`(fails), 
 - `x = 12`(fails), 
 - `x = 6`(fails), 
@@ -106,21 +166,28 @@ A short summary:
 - Arrays and hashes shrink to fewer elements, as well as shrinking their elements.
 - Strings shrink to shorter strings, as well as characters earlier in their alphabet.
 
+### Builtin Generators
+
+PropCheck comes with [many builtin generators in the PropCheck::Generators](https://www.rubydoc.info/github/Qqwy/ruby-prop_check/master/PropCheck/Generators) module.
+
+It contains generators for:
+- (any, positive, negative, etc.) integers, 
+- (any, only real-valued) floats, 
+- (any, printable only, alphanumeric only, etc) strings and symbols
+- fixed-size arrays and hashes 
+- as well as varying-size arrays and hashes.
+- and many more!
+
+It is common to call `include PropCheck::Generators` in e.g. your testing-suite files to be able to use these.
+If you want to be more explicit (but somewhat more verbose) when calling these functions. feel free to e.g. create a module-alias (like `PG = PropCheck::Generators`) instead.
 
 ### Writing Custom Generators
 
-PropCheck comes bundled with a bunch of common generators, for:
-- integers
-- floats
-- strings
-- symbols
-- arrays
-- hashes
-etc.
+As described in the previous section, PropCheck already comes bundled with a bunch of common generators.
 
 However, you can easily adapt them to generate your own datatypes:
 
-#### Generator#wrap
+#### Generators#constant / Generator#wrap
 
 Always returns the given value. No shrinking.
 

data/lib/prop_check.rb

@@ -9,6 +9,13 @@ require 'prop_check/helper'
 # You probably want to look at the documentation of
 # PropCheck::Generator and PropCheck::Generators
 # to find out more about how to use generators.
+#
+# Common usage is to call `extend PropCheck` in your (testing) modules.
+#
+# This will:
+# 1. Add the local method `forall` which  will call `PropCheck.forall`
+# 2. `include PropCheck::Generators`.
+#
 module PropCheck
   module Errors
     class Error < StandardError; end

data/lib/prop_check/generator.rb

@@ -72,7 +72,7 @@ module PropCheck
       #   end.flatten
       # end
       Generator.new do |size, rng|
-        outer_result = generate(size, rng)
+        outer_result = self.generate(size, rng)
         outer_result.bind do |outer_val|
           inner_generator = generator_proc.call(outer_val)
           inner_generator.generate(size, rng)
@@ -91,5 +91,24 @@ module PropCheck
         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)
+          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/helper.rb

@@ -23,5 +23,13 @@ module PropCheck
         end
       end.lazy
     end
+
+    ##
+    # allow lazy appending of two (potentially lazy) enumerators:
+    #   >> PropCheck::Helper::LazyAppend.lazy_append([1,2,3],[4,5.6]).to_a
+    #   => [1,2,3,4,5,6]
+    def lazy_append(this_enumerator, other_enumerator)
+      [this_enumerator, other_enumerator].lazy.flat_map(&:lazy)
+    end
   end
 end

data/lib/prop_check/helper/lazy_append.rb

@@ -1,18 +1,18 @@
-module PropCheck
-  module Helper
-    ##
-    # A refinement for enumerators
-    # to allow lazy appending of two (potentially lazy) enumerators:
-    #   >> [1,2,3].lazy_append([4,5.6]).to_a
-    #   => [1,2,3,4,5,6]
-    module LazyAppend
-      refine Enumerable do
-        ##   >> [1,2,3].lazy_append([4,5.6]).to_a
-        ##   => [1,2,3,4,5,6]
-        def lazy_append(other_enumerator)
-          [self, other_enumerator].lazy.flat_map(&:lazy)
-        end
-      end
-    end
-  end
-end
+# module PropCheck
+#   module Helper
+#     ##
+#     # A refinement for enumerators
+#     # to allow lazy appending of two (potentially lazy) enumerators:
+#     #   >> [1,2,3].lazy_append([4,5.6]).to_a
+#     #   => [1,2,3,4,5,6]
+#     module LazyAppend
+#       refine Enumerable do
+#         ##   >> [1,2,3].lazy_append([4,5.6]).to_a
+#         ##   => [1,2,3,4,5,6]
+#         def lazy_append(other_enumerator)
+#           [self, other_enumerator].lazy.flat_map(&:lazy)
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/prop_check/hooks.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+##
+# @api private
+# Contains the logic to combine potentially many before/after/around hooks
+# into a single pair of procedures called `before` and `after`.
+#
+# _Note: This module is an implementation detail of PropCheck._
+#
+# These can be invoked by manually calling `#before` and `#after`.
+# Important:
+# - Always call first `#before` and then `#after`.
+#   This is required to make sure that `around` callbacks will work properly.
+# - Make sure that if you call `#before`, to also call `#after`.
+#   It is thus highly recommended to call `#after` inside an `ensure`.
+#   This is to make sure that `around` callbacks indeed perform their proper cleanup.
+#
+# Alternatively, check out `PropCheck::Hooks::Enumerable` which allows
+# 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) }
+  end
+
+  def wrap_enum(enumerable)
+    PropCheck::Hooks::Enumerable.new(enumerable, self)
+  end
+
+
+  ##
+  # Wraps a block with all hooks that were configured this far.
+  #
+  # This means that whenever the block is called,
+  # the before/around/after hooks are called before/around/after it.
+  def wrap_block(&block)
+    proc { |*args| call(*args, &block) }
+  end
+
+  ##
+  # Wraps a block with all hooks that were configured this far,
+  # and immediately calls it using the given `*args`.
+  #
+  # See also #wrap_block
+  def call(*args, &block)
+    begin
+      @before.call()
+      @around.call do
+        block.call(*args)
+      end
+    ensure
+      @after.call()
+    end
+  end
+
+  ##
+  # 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
+      hook.call
+    }
+  end
+
+  ##
+  # Adds `hook` to the `after` proc.
+  # It is called before earlier-added `after` procs.
+  def add_after(&hook)
+    old_after = @after
+    @after = proc {
+      hook.call
+      old_after.call
+    }
+  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|
+        hook.call(*args, &block)
+      end
+    end
+  end
+
+  ##
+  # @api private
+  # Wraps enumerable `inner` with a `PropCheck::Hooks` object
+  # such that the before/after/around hooks are called
+  # before/after/around each element that is fetched from `inner`.
+  #
+  # This is very helpful if you need to perform cleanup logic
+  # before/after/around e.g. data is generated or fetched.
+  #
+  # Note that whatever is after a `yield` in an `around` hook
+  # is not guaranteed to be called (for instance when a StopIteration is raised).
+  # Thus: make sure you use `ensure` to clean up resources.
+  class Enumerable
+    include ::Enumerable
+
+    def initialize(inner, hooks)
+      @inner = inner
+      @hooks = hooks
+    end
+
+    def each(&task)
+      return to_enum(:each) unless block_given?
+
+      enum = @inner.to_enum
+
+      wrapped_yielder = @hooks.wrap_block do
+        yield enum.next(&task)
+      end
+
+      loop(&wrapped_yielder)
+    end
+  end
+end

data/lib/prop_check/lazy_tree.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require 'prop_check/helper/lazy_append'
-
 module PropCheck
   ##
   # A Rose tree with the root being eager,
   # and the children computed lazily, on demand.
   class LazyTree
-    using PropCheck::Helper::LazyAppend
+    require 'prop_check/helper'
 
     attr_accessor :root, :children
     def initialize(root, children = [].lazy)
@@ -38,7 +36,7 @@ module PropCheck
     #   root_children = root_tree.children
     #   flattened_children = children.map(&:flatten)
 
-    #   combined_children = root_children.lazy_append(flattened_children)
+    #   combined_children = PropCheck::Helper.lazy_append(root_children, flattened_children)
 
     #   LazyTree.new(root_root, combined_children)
     # end
@@ -53,7 +51,7 @@ module PropCheck
       inner_children = inner_tree.children
       mapped_children = children.map { |child| child.bind(&fun) }
 
-      combined_children = inner_children.lazy_append(mapped_children)
+      combined_children = PropCheck::Helper.lazy_append(inner_children, mapped_children)
 
       LazyTree.new(inner_root, combined_children)
     end
@@ -70,14 +68,15 @@ module PropCheck
     def each(&block)
       squish = lambda do |tree, list|
         new_children = tree.children.reduce(list) { |acc, elem| squish.call(elem, acc) }
-        [tree.root].lazy_append(new_children)
+        PropCheck::Helper.lazy_append([tree.root], new_children)
       end
 
-      squish.call(self, [])
+      squish
+        .call(self, [])
 
       # base = [root]
       # recursive = children.map(&:each)
-      # res = base.lazy_append(recursive)
+      # res = PropCheck::Helper.lazy_append(base, recursive)
 
       # return res.each(&block) if block_given?
 
@@ -99,7 +98,8 @@ module PropCheck
     #   >> LazyTree.new(1, [LazyTree.new(2, [LazyTree.new(3)]), LazyTree.new(4)]).to_a
     #   => [1, 4, 2, 3]
     def to_a
-      each.force
+      each
+        .force
     end
 
     # TODO: fix implementation

data/lib/prop_check/property.rb

@@ -2,24 +2,42 @@ require 'stringio'
 require "awesome_print"
 
 require 'prop_check/property/configuration'
-require 'prop_check/property/check_evaluator'
+require 'prop_check/property/output_formatter'
+require 'prop_check/property/shrinker'
+require 'prop_check/hooks'
 module PropCheck
   ##
   # Run properties
   class Property
 
     ##
-    # Call this with a keyword argument list of (symbol => generators) and a block.
-    # The block will then be executed many times, with the respective symbol names
-    # being defined as having a single generated value.
+    # Main entry-point to create (and possibly immediately run) a property-test.
+    #
+    # This method accepts a list of generators and a block.
+    # The block will then be executed many times, passing the values generated by the generators
+    # as respective arguments:
+    #
+    # ```
+    # include PropCheck::Generators
+    # PropCheck.forall(integer(), float()) { |x, y| ... }
+    # ```
+    #
+    # It is also possible (and recommended when having more than a few generators) to use a keyword-list
+    # of generators instead:
+    #
+    # ```
+    # include PropCheck::Generators
+    # PropCheck.forall(x: integer(), y: float()) { |x:, y:| ... }
+    # ```
+    #
     #
     # If you do not pass a block right away,
     # 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(a: Generators.integer) do ... end` and forall(a: Generators.integer).check do ... end` are the same)
-    def self.forall(**bindings, &block)
+    # (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)
+      property = new(*bindings)
 
       return property.check(&block) if block_given?
 
@@ -45,12 +63,14 @@ module PropCheck
 
     attr_reader :bindings, :condition
 
-    def initialize(**bindings)
-      raise ArgumentError, 'No bindings specified!' if bindings.empty?
+    def initialize(*bindings, **kwbindings)
+      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
 
       @bindings = bindings
-      @condition = -> { true }
+      @kwbindings = kwbindings
+      @condition = proc { true }
       @config = self.class.configuration
+      @hooks = PropCheck::Hooks.new
     end
 
     ##
@@ -87,21 +107,69 @@ module PropCheck
     # Only filter if you have few inputs to reject. Otherwise, improve your generators.
     def where(&condition)
       original_condition = @condition.dup
-      @condition = -> { instance_exec(&original_condition) && instance_exec(&condition) }
+      @condition = proc do |*args|
+        original_condition.call(*args) && condition.call(*args)
+      end
 
       self
     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
+    end
+
+    ##
+    # Calls `hook` after each time a check is run with new data.
+    #
+    # 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
+    end
+
+    ##
+    # Calls `hook` around each time a check is run with new data.
+    #
+    # `hook` should `yield` to the passed block.
+    #
+    # When called multiple times, earlier-added hooks will be wrapped _around_ `hook`.
+    #
+    # Around hooks will be called after all `#before` hooks
+    # and before all `#after` hooks.
+    #
+    # Note that if the block passed to `hook` raises an exception,
+    # 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
+    end
+
     ##
     # Checks the property (after settings have been altered using the other instance methods in this class.)
     def check(&block)
-      binding_generator = PropCheck::Generators.fixed_hash(bindings)
+      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_enumerator(binding_generator).each do |generator_result|
+      attempts_enum(binding_generator).each do |generator_result|
         n_runs += 1
         check_attempt(generator_result, n_successful, &block)
         n_successful += 1
@@ -113,6 +181,10 @@ module PropCheck
     private def ensure_not_exhausted!(n_runs)
       return if n_runs >= @config.n_runs
 
+      raise_generator_exhausted!
+    end
+
+    private def raise_generator_exhausted!()
       raise Errors::GeneratorExhaustedError, """
         Could not perform `n_runs = #{@config.n_runs}` runs,
         (exhausted #{@config.max_generate_attempts} tries)
@@ -124,7 +196,7 @@ module PropCheck
     end
 
     private def check_attempt(generator_result, n_successful, &block)
-      CheckEvaluator.new(generator_result.root, &block).call
+      block.call(*generator_result.root)
 
     # immediately stop (without shrinnking) for when the app is asked
     # to close by outside intervention
@@ -152,100 +224,39 @@ module PropCheck
       raise e, output_string, e.backtrace
     end
 
-    private def attempts_enumerator(binding_generator)
+    private def attempts_enum(binding_generator)
+        @hooks
+        .wrap_enum(raw_attempts_enum(binding_generator))
+        .lazy
+        .take(@config.n_runs)
+    end
 
+    private def raw_attempts_enum(binding_generator)
       rng = Random::DEFAULT
-      n_runs = 0
       size = 1
       (0...@config.max_generate_attempts)
         .lazy
         .map { binding_generator.generate(size, rng) }
-        .reject { |val| val.root == :"_PropCheck.filter_me" }
-        .select { |val| CheckEvaluator.new(val.root, &@condition).call }
+        .reject { |val| val.root.any? { |elem| elem == :"_PropCheck.filter_me" }}
+        .select { |val| @condition.call(*val.root) }
         .map do |result|
-          n_runs += 1
           size += 1
 
           result
         end
-        .take_while { n_runs <= @config.n_runs }
     end
 
     private def show_problem_output(problem, generator_results, n_successful, &block)
       output = @config.verbose ? STDOUT : StringIO.new
-      output = pre_output(output, n_successful, generator_results.root, problem)
+      output = PropCheck::Property::OutputFormatter.pre_output(output, n_successful, generator_results.root, problem)
       shrunken_result, shrunken_exception, n_shrink_steps = shrink(generator_results, output, &block)
-      output = post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
+      output = PropCheck::Property::OutputFormatter.post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
 
       [output, shrunken_result, shrunken_exception, n_shrink_steps]
     end
 
-    private def pre_output(output, n_successful, generated_root, problem)
-      output.puts ""
-      output.puts "(after #{n_successful} successful property test runs)"
-      output.puts "Failed on: "
-      output.puts "`#{print_roots(generated_root)}`"
-      output.puts ""
-      output.puts "Exception message:\n---\n#{problem}"
-      output.puts "---"
-      output.puts ""
-
-      output
-    end
-
-    private def post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
-      output.puts ''
-      output.puts "Shrunken input (after #{n_shrink_steps} shrink steps):"
-      output.puts "`#{print_roots(shrunken_result)}`"
-      output.puts ""
-      output.puts "Shrunken exception:\n---\n#{shrunken_exception}"
-      output.puts "---"
-      output.puts ""
-
-      output
-    end
-
-    private def print_roots(lazy_tree_hash)
-      # lazy_tree_hash.map do |name, val|
-      #   "#{name} = #{val.inspect}"
-      # end.join(", ")
-      lazy_tree_hash.ai
-    end
-
-    private def shrink(bindings_tree, io, &fun)
-      io.puts 'Shrinking...' if @config.verbose
-      problem_child = bindings_tree
-      siblings = problem_child.children.lazy
-      parent_siblings = nil
-      problem_exception = nil
-      shrink_steps = 0
-      (0..@config.max_shrink_steps).each do
-        begin
-          sibling = siblings.next
-        rescue StopIteration
-          break if parent_siblings.nil?
-
-          siblings = parent_siblings.lazy
-          parent_siblings = nil
-          next
-        end
-
-        shrink_steps += 1
-        io.print '.' if @config.verbose
-
-        begin
-          CheckEvaluator.new(sibling.root, &fun).call
-        rescue Exception => e
-          problem_child = sibling
-          parent_siblings = siblings
-          siblings = problem_child.children.lazy
-          problem_exception = e
-        end
-      end
-
-      io.puts "(Note: Exceeded #{@config.max_shrink_steps} shrinking steps, the maximum.)" if shrink_steps >= @config.max_shrink_steps
-
-      [problem_child.root, problem_exception, shrink_steps]
+    private def shrink(bindings_tree, io, &block)
+      PropCheck::Property::Shrinker.call(bindings_tree, io, @hooks, @config, &block)
     end
   end
 end

data/lib/prop_check/property/output_formatter.rb

@@ -0,0 +1,41 @@
+##
+# @api private
+module PropCheck::Property::OutputFormatter
+  extend self
+
+  def pre_output(output, n_successful, generated_root, problem)
+    output.puts ""
+    output.puts "(after #{n_successful} successful property test runs)"
+    output.puts "Failed on: "
+    output.puts "`#{print_roots(generated_root)}`"
+    output.puts ""
+    output.puts "Exception message:\n---\n#{problem}"
+    output.puts "---"
+    output.puts ""
+
+    output
+  end
+
+  def post_output(output, n_shrink_steps, shrunken_result, shrunken_exception)
+    if n_shrink_steps == 0
+      output.puts '(shrinking impossible)'
+    else
+      output.puts ''
+      output.puts "Shrunken input (after #{n_shrink_steps} shrink steps):"
+      output.puts "`#{print_roots(shrunken_result)}`"
+      output.puts ""
+      output.puts "Shrunken exception:\n---\n#{shrunken_exception}"
+      output.puts "---"
+      output.puts ""
+    end
+    output
+  end
+
+  def print_roots(lazy_tree_val)
+    if lazy_tree_val.is_a?(Array) && lazy_tree_val.length == 1 && lazy_tree_val[0].is_a?(Hash)
+      lazy_tree_val[0].ai
+    else
+      lazy_tree_val.ai
+    end
+  end
+end

data/lib/prop_check/property/shrinker.rb

@@ -0,0 +1,79 @@
+class PropCheck::Property::Shrinker
+  def initialize(bindings_tree, io, hooks, config)
+    @problem_child = bindings_tree
+    @io = io
+    @siblings = @problem_child.children.lazy
+    @parent_siblings = nil
+    @problem_exception = nil
+    @shrink_steps = 0
+    @hooks = hooks
+    @config = config
+  end
+
+  def self.call(bindings_tree, io, hooks, config, &block)
+    self
+      .new(bindings_tree, io, hooks, config)
+      .call(&block)
+  end
+
+  def call(&block)
+    @io.puts 'Shrinking...' if @config.verbose
+
+    shrink(&block)
+
+    print_shrinking_exceeded_message if @shrink_steps >= @config.max_shrink_steps
+
+    [@problem_child.root, @problem_exception, @shrink_steps]
+  end
+
+  private def shrink(&block)
+    wrapped_enum.each do
+      instruction, sibling = safe_read_sibling
+      break if instruction == :break
+      next if instruction == :next
+
+      inc_shrink_step
+
+      safe_call_block(sibling, &block)
+    end
+  end
+
+  private def wrapped_enum
+    @hooks.wrap_enum(0..@config.max_shrink_steps).lazy
+  end
+
+  private def inc_shrink_step
+    @shrink_steps += 1
+    @io.print '.' if @config.verbose
+  end
+
+  private def safe_read_sibling
+    begin
+      sibling = @siblings.next
+      [:continue, sibling]
+    rescue StopIteration
+      return [:break, nil] if @parent_siblings.nil?
+
+      @siblings = @parent_siblings.lazy
+      @parent_siblings = nil
+      [:next, nil]
+    end
+  end
+
+  private def safe_call_block(sibling, &block)
+    begin
+      block.call(*sibling.root)
+    # It is correct that we want to rescue _all_ Exceptions
+    # not only 'StandardError's
+    rescue Exception => e
+      @problem_child = sibling
+      @parent_siblings = @siblings
+      @siblings = @problem_child.children.lazy
+      @problem_exception = e
+    end
+  end
+
+  private def print_shrinking_exceeded_message
+    @io.puts "(Note: Exceeded #{@config.max_shrink_steps} shrinking steps, the maximum.)"
+  end
+end

data/lib/prop_check/version.rb

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

data/prop_check.gemspec

@@ -36,7 +36,5 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.5.1'
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 12.3"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency 'awesome_print', '~> 1.8'
 end

metadata

@@ -1,57 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.10.2
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-06-19 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: awesome_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :development
+        version: '1.8'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '12.3'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '1.8'
 description: PropCheck allows you to do property-based testing, including shrinking.
   (akin to Haskell's QuickCheck, Erlang's PropEr, Elixir's StreamData). This means
   that your test are run many times with different, autogenerated inputs, and as soon
@@ -71,7 +43,6 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -82,11 +53,12 @@ files:
 - lib/prop_check/generators.rb
 - lib/prop_check/helper.rb
 - lib/prop_check/helper/lazy_append.rb
+- lib/prop_check/hooks.rb
 - lib/prop_check/lazy_tree.rb
 - lib/prop_check/property.rb
-- lib/prop_check/property/check_evaluator.rb
 - lib/prop_check/property/configuration.rb
-- lib/prop_check/rspec.rb
+- lib/prop_check/property/output_formatter.rb
+- lib/prop_check/property/shrinker.rb
 - lib/prop_check/version.rb
 - prop_check.gemspec
 homepage: https://github.com/Qqwy/ruby-prop_check/

data/Gemfile.lock

@@ -1,50 +0,0 @@
-PATH
-  remote: .
-  specs:
-    prop_check (0.7.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    awesome_print (1.8.0)
-    diff-lcs (1.3)
-    docile (1.3.2)
-    doctest-core (0.0.2)
-    doctest-rspec (0.0.3)
-      doctest-core (~> 0.0.2)
-      rspec
-    json (2.2.0)
-    rake (12.3.3)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.1)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    simplecov (0.16.1)
-      docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  awesome_print
-  bundler (~> 2.0)
-  doctest-rspec
-  prop_check!
-  rake (~> 12.3)
-  rspec (~> 3.0)
-  simplecov
-
-BUNDLED WITH
-   2.1.4

data/lib/prop_check/property/check_evaluator.rb

@@ -1,45 +0,0 @@
-module PropCheck
-  class Property
-    ##
-    # A wrapper class that implements the 'Cloaker' concept
-    # which allows us to refer to variables set in 'bindings',
-    # while still being able to access things that are only in scope
-    # in the creator of '&block'.
-    #
-    # This allows us to bind the variables specified in `bindings`
-    # one way during checking and another way during shrinking.
-    class CheckEvaluator
-      include RSpec::Matchers if Object.const_defined?('RSpec')
-
-      def initialize(bindings, &block)
-        @caller = block.binding.receiver
-        @block = block
-        define_named_instance_methods(bindings)
-      end
-
-      def call
-        self.instance_exec(&@block)
-      end
-
-      private def define_named_instance_methods(results)
-        results.each do |name, result|
-          define_singleton_method(name) { result }
-        end
-      end
-
-      ##
-      # Dispatches to caller whenever something is not part of `bindings`.
-      # (No need to invoke this method manually)
-      def method_missing(method, *args, &block)
-        @caller.__send__(method, *args, &block) || super
-      end
-
-      ##
-      # Checks respond_to of caller whenever something is not part of `bindings`.
-      # (No need to invoke this method manually)
-      def respond_to_missing?(*args)
-        @caller.respond_to?(*args) || super
-      end
-    end
-  end
-end

data/lib/prop_check/rspec.rb

@@ -1,18 +0,0 @@
-module PropCheck
-  ##
-  # Integration with RSpec
-  module RSpec
-    # To make it available within examples
-    def self.extend_object(obj)
-      obj.define_method(:forall) do |*args, **kwargs, &block|
-        if block_given?
-          PropCheck::Property.forall(*args, **kwargs) do
-            instance_exec(self, &block)
-          end
-        else
-          PropCheck::Property.forall(*args, **kwargs)
-        end
-      end
-    end
-  end
-end