prop_check 0.6.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4beba1b773706a7e7f75696a7040667172e44646246dc9ccdbc87faa03f70f55
-  data.tar.gz: 2c6e0c8aabc7c9c69da74c11ad2e79461ed5f6e1c5e550b0eb32923366f84c84
+  metadata.gz: aaa23e40547bec5672e806d62c567947cd596e1c11ed2bc80fbe6912cd75a777
+  data.tar.gz: a0263cddf3efb8ee55f29395004915c38b6e78c7fc7bbf2c1b456f344013b8da
 SHA512:
-  metadata.gz: 25a28c29aaedcfcff34a5fa8f3c7164b6df7536eed2134416467dd46b7c8502530c6511cf6b54d0ca2f1b8ee3b59ffaa62dc6a132667a0179f0dbead7fcf6b41
-  data.tar.gz: d9d9790f110d56920570e25d2ed2b6ee0657ec99bc46b509593215405fe19de6545ecaa990a096fd75259d9122c7a7404a9f2e6194cc808707ed01f8489201ed
+  metadata.gz: b7976fb344d4c7135cd858ca86606beb97cd9e9f57c40e2bb322a3c76287de46491d4feb1dd3a65158ffef8ea98894490edc7eb9bc506d80ddb110b2f026de8d
+  data.tar.gz: f80bffd3b08d1a1cf120a70645b548c2f70b540ae5be317b7635f7416cc4e7be94d3a1bfca10acd117166e08fd0a0c6cd8ab08bf68097182fc064519600cfb55

data/.gitignore

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

data/.tool-versions

@@ -1 +1 @@
-ruby 2.5.1
+ruby 2.6.5

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,5 +3,9 @@ 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 "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
+

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:
 
@@ -26,11 +26,12 @@ Before releasing this gem on Rubygems, the following things need to be finished:
   - [x] Stop after a ludicrous amount of generator runs, to prevent malfunctioning (infinitely looping) generators from blowing up someone's computer.
  - [x] Look into customization of settings from e.g. command line arguments.
 - [x] Good, unicode-compliant, string generators.
-- [ ] Filtering generator outputs.
+- [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/hooks.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+##
+# 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
+
+  ##
+  # 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

@@ -73,7 +73,8 @@ module PropCheck
         [tree.root].lazy_append(new_children)
       end
 
-      squish.call(self, [])
+      squish
+        .call(self, [])
 
       # base = [root]
       # recursive = children.map(&:each)
@@ -99,7 +100,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

@@ -1,24 +1,41 @@
 require 'stringio'
+require "awesome_print"
 
 require 'prop_check/property/configuration'
-require 'prop_check/property/check_evaluator'
+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?
 
@@ -44,12 +61,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
 
     ##
@@ -86,21 +105,46 @@ 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
 
+    def before(&hook)
+      @hooks.add_before(&hook)
+      self
+    end
+
+    def after(&hook)
+      @hooks.add_after(&hook)
+      self
+    end
+
+    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
@@ -112,6 +156,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)
@@ -123,7 +171,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
@@ -151,23 +199,26 @@ 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)
@@ -193,31 +244,36 @@ module PropCheck
     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 ""
-
+      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_hash)
-      lazy_tree_hash.map do |name, val|
-        "#{name} = #{val.inspect}"
-      end.join(", ")
+    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, &fun)
+    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
+      @hooks.wrap_enum(0..@config.max_shrink_steps).lazy.each do
         begin
           sibling = siblings.next
         rescue StopIteration
@@ -232,7 +288,7 @@ module PropCheck
         io.print '.' if @config.verbose
 
         begin
-          CheckEvaluator.new(sibling.root, &fun).call
+          block.call(*sibling.root)
         rescue Exception => e
           problem_child = sibling
           parent_siblings = siblings

data/lib/prop_check/version.rb

@@ -1,3 +1,3 @@
 module PropCheck
-  VERSION = "0.6.2"
+  VERSION = '0.10.0'
 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", "~> 10.0"
-  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.6.2
+  version: 0.10.0
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-07-04 00:00:00.000000000 Z
+date: 2020-07-29 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: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !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,10 @@ 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/version.rb
 - prop_check.gemspec
 homepage: https://github.com/Qqwy/ruby-prop_check/
@@ -96,7 +66,7 @@ metadata:
   homepage_uri: https://github.com/Qqwy/ruby-prop_check/
   source_code_uri: https://github.com/Qqwy/ruby-prop_check/
   changelog_uri: https://github.com/Qqwy/ruby-prop_check/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,9 +81,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: PropCheck allows you to do property-based testing, including shrinking.
 test_files: []

data/Gemfile.lock

@@ -1,48 +0,0 @@
-PATH
-  remote: .
-  specs:
-    prop_check (0.6.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    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 (10.5.0)
-    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
-  bundler (~> 2.0)
-  doctest-rspec
-  prop_check!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  simplecov
-
-BUNDLED WITH
-   2.0.2

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,14 +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|
-        PropCheck::Property.forall(*args, **kwargs) do
-          instance_exec(self, &block)
-        end
-      end
-    end
-  end
-end