prop_check 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaa23e40547bec5672e806d62c567947cd596e1c11ed2bc80fbe6912cd75a777
-  data.tar.gz: a0263cddf3efb8ee55f29395004915c38b6e78c7fc7bbf2c1b456f344013b8da
+  metadata.gz: 5b0170f4c948f3ffb903842c33204d4a9d5f74dd4f1d29313a60dec638670623
+  data.tar.gz: 447b87275c1e379502694d96591a871a527535e290daf3cc255476965752e1d2
 SHA512:
-  metadata.gz: b7976fb344d4c7135cd858ca86606beb97cd9e9f57c40e2bb322a3c76287de46491d4feb1dd3a65158ffef8ea98894490edc7eb9bc506d80ddb110b2f026de8d
-  data.tar.gz: f80bffd3b08d1a1cf120a70645b548c2f70b540ae5be317b7635f7416cc4e7be94d3a1bfca10acd117166e08fd0a0c6cd8ab08bf68097182fc064519600cfb55
+  metadata.gz: 533aae467c23eb1ecc974e842e735b49f3cfdef7ae51090ef11ad86e95f90f81660a6617565df4aab6470d2c2ae9ff5978826b48ed2686a727ac53b7c065a7b1
+  data.tar.gz: 4d6cc50716b03427a0aba7c4617a2970cc791c524d6aa427d22a63870853118cd72c6eca469fcd1e42ce2288f42a63b7fc577b248aea47a2892f324d94377db8

data/Gemfile

@@ -4,8 +4,10 @@ source "https://rubygems.org"
 gemspec
 
 gem "bundler", "~> 2.0"
-gem "rake", "~> 12.3", require: false, group: :test
-gem "rspec", "~> 3.0", require: false, group: :test
-gem "doctest-rspec", require: false, group: :test
-gem "simplecov", require: false, group: :test
 
+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/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

@@ -1,6 +1,7 @@
 # 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`.
 #
@@ -89,6 +90,7 @@ class PropCheck::Hooks
   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`.

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,7 +68,7 @@ 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
@@ -78,7 +76,7 @@ module PropCheck
 
       # 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?
 

data/lib/prop_check/property.rb

@@ -2,6 +2,8 @@ require 'stringio'
 require "awesome_print"
 
 require 'prop_check/property/configuration'
+require 'prop_check/property/output_formatter'
+require 'prop_check/property/shrinker'
 require 'prop_check/hooks'
 module PropCheck
   ##
@@ -112,16 +114,39 @@ module PropCheck
       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
@@ -223,83 +248,15 @@ module PropCheck
 
     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)
-      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
-
-    private 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
-
     private def shrink(bindings_tree, io, &block)
-      io.puts 'Shrinking...' if @config.verbose
-      problem_child = bindings_tree
-      siblings = problem_child.children.lazy
-      parent_siblings = nil
-      problem_exception = nil
-      shrink_steps = 0
-      @hooks.wrap_enum(0..@config.max_shrink_steps).lazy.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
-          block.call(*sibling.root)
-        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]
+      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.10.0'
+  VERSION = '0.10.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-29 00:00:00.000000000 Z
+date: 2020-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -57,6 +57,8 @@ files:
 - lib/prop_check/lazy_tree.rb
 - lib/prop_check/property.rb
 - lib/prop_check/property/configuration.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/