prop_check 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aaa23e40547bec5672e806d62c567947cd596e1c11ed2bc80fbe6912cd75a777
-  data.tar.gz: a0263cddf3efb8ee55f29395004915c38b6e78c7fc7bbf2c1b456f344013b8da
+  metadata.gz: 6938e33edff09860d467d560675d04173ac8f44c487f65f22a4253bcad01a465
+  data.tar.gz: 1ed4f6b097d008461e251f285ad52fcd32dfce27cc306862b250cea45e0b954a
 SHA512:
-  metadata.gz: b7976fb344d4c7135cd858ca86606beb97cd9e9f57c40e2bb322a3c76287de46491d4feb1dd3a65158ffef8ea98894490edc7eb9bc506d80ddb110b2f026de8d
-  data.tar.gz: f80bffd3b08d1a1cf120a70645b548c2f70b540ae5be317b7635f7416cc4e7be94d3a1bfca10acd117166e08fd0a0c6cd8ab08bf68097182fc064519600cfb55
+  metadata.gz: e8d7498c00b09f17ec90fced0b130158e1919270837bad1af82ca7f4140f8904816c377cdd3489aea38d6ef36b911a128a92ca956c598daf9f0f88654ca4ac64
+  data.tar.gz: b05e4c9364808468af3c5b9807cc8cc8e036a780e449efd0468f7b577853bd3a286371a3312073c0cf5952c5debb12dd6b13ad2d3e8d0fed0952839db680757c

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/generator.rb

@@ -10,6 +10,7 @@ module PropCheck
   class Generator
     @@default_size = 10
     @@default_rng = Random.new
+    @@max_consecutive_attempts = 100
 
     ##
     # Being a special kind of Proc, a Generator wraps a block.
@@ -20,8 +21,19 @@ module PropCheck
     ##
     # Given a `size` (integer) and a random number generator state `rng`,
     # generate a LazyTree.
-    def generate(size = @@default_size, rng = @@default_rng)
-      @block.call(size, rng)
+    def generate(size = @@default_size, rng = @@default_rng, max_consecutive_attempts = @@max_consecutive_attempts)
+      (0..max_consecutive_attempts).each do
+        res = @block.call(size, rng)
+        next if res == :"PropCheck.filter_me"
+
+        return res
+      end
+
+      raise Errors::GeneratorExhaustedError, """
+      Exhausted #{max_consecutive_attempts} consecutive generation attempts.
+
+      Probably too few generator results were adhering to a `where` condition.
+      """
     end
 
     ##
@@ -96,7 +108,7 @@ 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)
           result
         else
           :"_PropCheck.filter_me"

data/lib/prop_check/generators.rb

@@ -227,19 +227,45 @@ module PropCheck
     # is generated by `element_generator`.
     #
     # Shrinks to shorter arrays (with shrunken elements).
+    # Accepted keyword arguments:
     #
+    # `empty:` When false, behaves the same as `min: 1`
+    # `min:` Ensures at least this many elements are generated. (default: 0)
+    # `max:` Ensures at most this many elements are generated. When nil, an arbitrary count is used instead. (default: nil)
+    #
+    #
+    #    >> Generators.array(Generators.positive_integer).sample(5, size: 1, rng: Random.new(42))
+    #    =>  [[2], [2], [2], [1], [2]]
     #    >> Generators.array(Generators.positive_integer).sample(5, size: 10, rng: Random.new(42))
     #    => [[10, 5, 1, 4], [5, 9, 1, 1, 11, 8, 4, 9, 11, 10], [6], [11, 11, 2, 2, 7, 2, 6, 5, 5], [2, 10, 9, 7, 9, 5, 11, 3]]
-    def array(element_generator)
-      nonnegative_integer.bind do |generator|
-        generators = (0...generator).map do
+    #
+    #    >> Generators.array(Generators.positive_integer, empty: true).sample(5, size: 1, rng: Random.new(1))
+    #    =>  [[], [2], [], [], [2]]
+    #    >> Generators.array(Generators.positive_integer, empty: false).sample(5, size: 1, rng: Random.new(1))
+    #    =>  [[2], [1], [2], [1], [1]]
+
+
+    def array(element_generator, min: 0, max: nil, empty: true)
+      min = 1 if min.zero? && !empty
+
+      res = proc do |count|
+        count = min + 1 if count < min
+        count += 1 if count == min && min != 0
+        generators = (min...count).map do
           element_generator.clone
         end
 
         tuple(*generators)
       end
+
+      if max.nil?
+        nonnegative_integer.bind(&res)
+      else
+        proc.call(max)
+      end
     end
 
+
     ##
     # Generates a hash of key->values,
     # where each of the keys is made using the `key_generator`
@@ -249,8 +275,8 @@ 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))
+    def hash(key_generator, value_generator, **kwargs)
+      array(tuple(key_generator, value_generator), **kwargs)
         .map(&:to_h)
     end
 
@@ -276,8 +302,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 +328,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 +367,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 +398,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 +424,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
 
     ##

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.11.0'
 end

metadata

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