prop_check 0.9.0 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e5aeef61ddf82569ca885327d32b9fe8fd939f2fdbef48709cb19504b5cf041
-  data.tar.gz: d914dcac32f7a3a976661a0280c71f0a7a665411550aed9902317b04c82ee290
+  metadata.gz: f8f707bae1dadf800e667376a749c7d5de3f3d741d13e63118de79dfb7233fb5
+  data.tar.gz: e86ac3b096bff66cfa88c0a66b1fc8ea91dc8452ded41c417fb1452c33c2b1d7
 SHA512:
-  metadata.gz: 85c5b76ac37ba8e03b2c41c04c4cc359844fa2e52d0af8893787531c23f3a54b046eb7eed13b055fed44c8983f87cbfe492d1524746624a3744300a73caf01da
-  data.tar.gz: 9beb7ac4e605c72cc8e9b3907e727ae532c2eec4a530b6a9b7c31445135e37c8849c9f186d4571aaf38c24e28989ebe856ed2e5e873baf2ed7b740a73561dae7
+  metadata.gz: e0985469e34e0b353aab0fac657a073fadfe135c03029187d3f7824ebded0bfd244122aa2ae4361b5ccad3fb05ca52162e3967e9f46a6e43674e7d7626a700f7
+  data.tar.gz: 0b0505768ea68855beaf9c8954cb973215dd392c40975e7f581e7faa9d7570c9e4fb76402227c5b0f223f96e87f72d58decfb7dffd2744897c22db3ba0959ac6

data/.gitignore

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

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

@@ -27,6 +27,7 @@ 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
  
@@ -87,7 +88,8 @@ Here we check if `naive_average` indeed always returns an integer for all arrays
 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:|
@@ -96,6 +98,19 @@ PropCheck.forall(numbers: array(integer)) do |numbers:|
     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:

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
 
     ##
@@ -88,14 +100,16 @@ module PropCheck
     def map(&proc)
       Generator.new do |size, rng|
         result = self.generate(size, rng)
-        result.map(&proc)
+        result.map do |*val|
+          proc.call(*val)
+        end
       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|
+      self.map do |*result|
         if condition.call(*result)
           result
         else

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,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,9 @@ 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
   ##
   # Run properties
@@ -67,6 +70,7 @@ module PropCheck
       @kwbindings = kwbindings
       @condition = proc { true }
       @config = self.class.configuration
+      @hooks = PropCheck::Hooks.new
     end
 
     ##
@@ -103,13 +107,51 @@ module PropCheck
     # Only filter if you have few inputs to reject. Otherwise, improve your generators.
     def where(&condition)
       original_condition = @condition.dup
-      @condition = proc do |**kwargs|
-        original_condition.call(**kwargs) && condition.call(**kwargs)
+      @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)
@@ -127,7 +169,7 @@ module PropCheck
       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
@@ -182,10 +224,15 @@ 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
@@ -193,93 +240,23 @@ module PropCheck
         .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)
-      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
-      (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
-          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.9.0"
+  VERSION = '0.10.4'
 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.9.0
+  version: 0.10.4
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-21 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,9 +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/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/

data/Gemfile.lock

@@ -1,50 +0,0 @@
-PATH
-  remote: .
-  specs:
-    prop_check (0.9.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