prop_check 0.11.0 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6938e33edff09860d467d560675d04173ac8f44c487f65f22a4253bcad01a465
-  data.tar.gz: 1ed4f6b097d008461e251f285ad52fcd32dfce27cc306862b250cea45e0b954a
+  metadata.gz: '099a3bafe1fae426f476e3add7fb93ab333506670c72c35bb78e5e505b9f0764'
+  data.tar.gz: d1c433ef97043f38c84a5bf8768fb46aa5fcc97f00518da831fbebc36142d2e5
 SHA512:
-  metadata.gz: e8d7498c00b09f17ec90fced0b130158e1919270837bad1af82ca7f4140f8904816c377cdd3489aea38d6ef36b911a128a92ca956c598daf9f0f88654ca4ac64
-  data.tar.gz: b05e4c9364808468af3c5b9807cc8cc8e036a780e449efd0468f7b577853bd3a286371a3312073c0cf5952c5debb12dd6b13ad2d3e8d0fed0952839db680757c
+  metadata.gz: 782411f48a77c4bc2213d6ecaecd70d7d7c3609c13bab2125ce853dedd7d3029fd8801ac882154d8c924cea212698740d8e330f8e2b90f460a5a87484413e560
+  data.tar.gz: dd18135801b66e2f073e82066506f8bb26cf031a4bd8d2fc208864acd7ef3a7ec564f8364628d34e4ab40429a5444a1dbc41f329bb4c7d3a608011407bb0a923

data/.tool-versions

@@ -1 +1 @@
-ruby 2.6.5
+ruby 2.7.1

data/lib/prop_check/generator.rb

@@ -11,6 +11,7 @@ module PropCheck
     @@default_size = 10
     @@default_rng = Random.new
     @@max_consecutive_attempts = 100
+    @@default_kwargs = {size: @@default_size, rng: @@default_rng, max_consecutive_attempts: @@max_consecutive_attempts}
 
     ##
     # Being a special kind of Proc, a Generator wraps a block.
@@ -21,12 +22,13 @@ module PropCheck
     ##
     # Given a `size` (integer) and a random number generator state `rng`,
     # generate a LazyTree.
-    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"
+    def generate(**kwargs)
+      kwargs = @@default_kwargs.merge(kwargs)
+      max_consecutive_attempts = kwargs[:max_consecutive_attempts]
 
-        return res
+      (0..max_consecutive_attempts).each do
+        res = @block.call(**kwargs)
+        return res unless res.root == :"_PropCheck.filter_me"
       end
 
       raise Errors::GeneratorExhaustedError, """
@@ -40,18 +42,18 @@ module PropCheck
     # Generates a value, and only return this value
     # (drop information for shrinking)
     #
-    #   >> Generators.integer.call(1000, Random.new(42))
+    #   >> Generators.integer.call(size: 1000, rng: Random.new(42))
     #   => 126
-    def call(size = @@default_size, rng = @@default_rng)
-      generate(size, rng).root
+    def call(**kwargs)
+      generate(**@@default_kwargs.merge(kwargs)).root
     end
 
     ##
     # Returns `num_of_samples` values from calling this Generator.
     # This is mostly useful for debugging if a generator behaves as you intend it to.
-    def sample(num_of_samples = 10, size: @@default_size, rng: @@default_rng)
+    def sample(num_of_samples = 10, **kwargs)
       num_of_samples.times.map do
-        call(size, rng)
+        call(**@@default_kwargs.merge(kwargs))
       end
     end
 
@@ -61,10 +63,10 @@ module PropCheck
     #
     # Keen readers may notice this as the Monadic 'pure'/'return' implementation for Generators.
     #
-    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(100, Random.new(42))
+    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(size: 100, rng: Random.new(42))
     #   => [2, 79]
     def self.wrap(val)
-      Generator.new { |_size, _rng| LazyTree.wrap(val) }
+      Generator.new { LazyTree.wrap(val) }
     end
 
     ##
@@ -73,7 +75,7 @@ module PropCheck
     #
     # Keen readers may notice this as the Monadic 'bind' (sometimes known as '>>=') implementation for Generators.
     #
-    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(100, Random.new(42))
+    #   >> Generators.integer.bind { |a| Generators.integer.bind { |b| Generator.wrap([a , b]) } }.call(size: 100, rng: Random.new(42))
     #   => [2, 79]
     def bind(&generator_proc)
       # Generator.new do |size, rng|
@@ -83,11 +85,11 @@ module PropCheck
       #     inner_generator.generate(size, rng)
       #   end.flatten
       # end
-      Generator.new do |size, rng|
-        outer_result = self.generate(size, rng)
+      Generator.new do |**kwargs|
+        outer_result = self.generate(**kwargs)
         outer_result.bind do |outer_val|
           inner_generator = generator_proc.call(outer_val)
-          inner_generator.generate(size, rng)
+          inner_generator.generate(**kwargs)
         end
       end
     end
@@ -95,11 +97,11 @@ module PropCheck
     ##
     # Creates a new Generator that returns a value by running `proc` on the output of the current Generator.
     #
-    #   >> Generators.choose(32..128).map(&:chr).call(10, Random.new(42))
+    #   >> Generators.choose(32..128).map(&:chr).call(size: 10, rng: Random.new(42))
     #   => "S"
     def map(&proc)
-      Generator.new do |size, rng|
-        result = self.generate(size, rng)
+      Generator.new do |**kwargs|
+        result = self.generate(**kwargs)
         result.map(&proc)
       end
     end
@@ -108,19 +110,13 @@ 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)
+        if PropCheck::Helper.call_splatted(result, &condition)
           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/generators.rb

@@ -10,6 +10,7 @@ module PropCheck
   # where you want to use them.
   module Generators
     extend self
+
     ##
     # Always returns the same value, regardless of `size` or `rng` (random number generator state)
     #
@@ -59,7 +60,7 @@ module PropCheck
     #   >> r = Random.new(42); Generators.choose(0..5).sample(size: 20000, rng: r)
     #   => [3, 4, 2, 4, 4, 1, 2, 2, 2, 4]
     def choose(range)
-      Generator.new do |_size, rng|
+      Generator.new do |rng:, **|
         val = rng.rand(range)
         LazyTree.new(val, integer_shrink(val))
       end
@@ -73,14 +74,14 @@ module PropCheck
     #
     # Shrinks to integers closer to zero.
     #
-    #   >> Generators.integer.call(2, Random.new(42))
+    #   >> Generators.integer.call(size: 2, rng: Random.new(42))
     #   => 1
-    #   >> Generators.integer.call(10000, Random.new(42))
+    #   >> Generators.integer.call(size: 10000, rng: Random.new(42))
     #   => 5795
     #   >> r = Random.new(42); Generators.integer.sample(size: 20000, rng: r)
     #   => [-4205, -19140, 18158, -8716, -13735, -3150, 17194, 1962, -3977, -18315]
     def integer
-      Generator.new do |size, rng|
+      Generator.new do |size:, rng:, **|
         val = rng.rand(-size..size)
         LazyTree.new(val, integer_shrink(val))
       end
@@ -193,12 +194,12 @@ module PropCheck
     #
     # Shrinks element generators, one at a time (trying last one first).
     #
-    #   >> Generators.tuple(Generators.integer, Generators.real_float).call(10, Random.new(42))
+    #   >> Generators.tuple(Generators.integer, Generators.real_float).call(size: 10, rng: Random.new(42))
     #   => [-4, 13.0]
     def tuple(*generators)
-      Generator.new do |size, rng|
+      Generator.new do |**kwargs|
         LazyTree.zip(generators.map do |generator|
-          generator.generate(size, rng)
+          generator.generate(**kwargs)
         end)
       end
     end
@@ -210,7 +211,7 @@ module PropCheck
     #
     # Shrinks element generators.
     #
-    #    >> Generators.fixed_hash(a: Generators.integer(), b: Generators.real_float(), c: Generators.integer()).call(10, Random.new(42))
+    #    >> Generators.fixed_hash(a: Generators.integer(), b: Generators.real_float(), c: Generators.integer()).call(size: 10, rng: Random.new(42))
     #    => {:a=>-4, :b=>13.0, :c=>-3}
     def fixed_hash(hash)
       keypair_generators =
@@ -265,7 +266,6 @@ module PropCheck
       end
     end
 
-
     ##
     # Generates a hash of key->values,
     # where each of the keys is made using the `key_generator`
@@ -275,12 +275,23 @@ 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, **kwargs)
+    def hash(*args, **kwargs)
+      if args.length == 2
+        hash_of(*args, **kwargs)
+      else
+        super
+      end
+    end
+
+    ##
+    #
+    # Alias for `#hash` that does not conflict with a possibly overriden `Object#hash`.
+    #
+    def hash_of(key_generator, value_generator, **kwargs)
       array(tuple(key_generator, value_generator), **kwargs)
         .map(&:to_h)
     end
 
-
     @alphanumeric_chars = [('a'..'z'), ('A'..'Z'), ('0'..'9')].flat_map(&:to_a).freeze
     ##
     # Generates a single-character string

data/lib/prop_check/helper.rb

@@ -31,5 +31,19 @@ module PropCheck
     def lazy_append(this_enumerator, other_enumerator)
       [this_enumerator, other_enumerator].lazy.flat_map(&:lazy)
     end
+
+    def call_splatted(val, &block)
+      case val
+      when Hash
+        block.call(**val)
+      else
+        block.call(val)
+      end
+      # if kwval != {}
+      #   block.call(**kwval)
+      # else
+      #   block.call(*val)
+      # end
+    end
   end
 end

data/lib/prop_check/lazy_tree.rb

@@ -7,6 +7,8 @@ module PropCheck
   class LazyTree
     require 'prop_check/helper'
 
+    include Enumerable
+
     attr_accessor :root, :children
     def initialize(root, children = [].lazy)
       @root = root
@@ -66,25 +68,15 @@ module PropCheck
     #   >> LazyTree.new(1, [LazyTree.new(2, [LazyTree.new(3)]), LazyTree.new(4)]).each.force
     #   => [1, 4, 2, 3]
     def each(&block)
-      squish = lambda do |tree, list|
-        new_children = tree.children.reduce(list) { |acc, elem| squish.call(elem, acc) }
-        PropCheck::Helper.lazy_append([tree.root], new_children)
-      end
-
-      squish
-        .call(self, [])
+      self.to_enum(:each) unless block_given?
 
-      # base = [root]
-      # recursive = children.map(&:each)
-      # res = PropCheck::Helper.lazy_append(base, recursive)
-
-      # return res.each(&block) if block_given?
-
-      # res
+      squish([])
+      .each(&block)
+    end
 
-      # res = [[root], children.flat_map(&:each)].lazy.flat_map(&:lazy)
-      # res = res.map(&block) if block_given?
-      # res
+    protected def squish(arr)
+      new_children = self.children.reduce(arr) { |acc, elem| elem.squish(acc) }
+      PropCheck::Helper.lazy_append([self.root], new_children)
     end
 
     ##

data/lib/prop_check/property.rb

@@ -35,9 +35,9 @@ module PropCheck
     # 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(Generators.integer) do |val| ... end` and forall(Generators.integer).check do |val| ... end` are the same)
-    def self.forall(*bindings, &block)
+    def self.forall(*bindings, **kwbindings, &block)
 
-      property = new(*bindings)
+      property = new(*bindings, **kwbindings)
 
       return property.check(&block) if block_given?
 
@@ -66,8 +66,9 @@ module PropCheck
     def initialize(*bindings, **kwbindings)
       raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
 
-      @bindings = bindings
-      @kwbindings = kwbindings
+      # @bindings = bindings
+      # @kwbindings = kwbindings
+      @gen = gen_from_bindings(bindings, kwbindings)
       @condition = proc { true }
       @config = self.class.configuration
       @hooks = PropCheck::Hooks.new
@@ -106,14 +107,17 @@ module PropCheck
     # you might encounter a GeneratorExhaustedError.
     # Only filter if you have few inputs to reject. Otherwise, improve your generators.
     def where(&condition)
-      original_condition = @condition.dup
-      @condition = proc do |*args|
-        original_condition.call(*args) && condition.call(*args)
-      end
+      # original_condition = @condition.dup
+      # @condition = proc do |val|
+      #   call_splatted(val, &original_condition) && call_splatted(val, &condition)
+      #   # original_condition.call(val) && condition.call(val)
+      # end
+      @gen = @gen.where(&condition)
 
       self
     end
 
+
     ##
     # Calls `hook` before each time a check is run with new data.
     #
@@ -155,21 +159,11 @@ module PropCheck
     ##
     # Checks the property (after settings have been altered using the other instance methods in this class.)
     def check(&block)
-      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_enum(binding_generator).each do |generator_result|
+      attempts_enum(@gen).each do |generator_result|
         n_runs += 1
         check_attempt(generator_result, n_successful, &block)
         n_successful += 1
@@ -178,6 +172,25 @@ module PropCheck
       ensure_not_exhausted!(n_runs)
     end
 
+    private def gen_from_bindings(bindings, kwbindings)
+      if bindings == [] && kwbindings != {}
+        PropCheck::Generators.fixed_hash(**kwbindings)
+      elsif bindings != [] && kwbindings == {}
+        if bindings.size == 1
+          bindings.first
+        else
+          PropCheck::Generators.tuple(*bindings)
+        end
+      else
+        raise ArgumentError,
+              'Attempted to use both normal and keyword bindings at the same time.
+This is not supported because of the separation of positional and keyword arguments
+(the old behaviour is deprecated in Ruby 2.7 and will be removed in 3.0)
+c.f. https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+     '
+      end
+    end
+
     private def ensure_not_exhausted!(n_runs)
       return if n_runs >= @config.n_runs
 
@@ -196,7 +209,7 @@ module PropCheck
     end
 
     private def check_attempt(generator_result, n_successful, &block)
-      block.call(*generator_result.root)
+      PropCheck::Helper.call_splatted(generator_result.root, &block)
 
     # immediately stop (without shrinnking) for when the app is asked
     # to close by outside intervention
@@ -236,9 +249,7 @@ module PropCheck
       size = 1
       (0...@config.max_generate_attempts)
         .lazy
-        .map { binding_generator.generate(size, rng) }
-        .reject { |val| val.root.any? { |elem| elem == :"_PropCheck.filter_me" }}
-        .select { |val| @condition.call(*val.root) }
+        .map { binding_generator.generate(size: size, rng: rng, max_consecutive_attempts: @config.max_consecutive_attempts) }
         .map do |result|
           size += 1
 

data/lib/prop_check/property/configuration.rb

@@ -1,8 +1,20 @@
 module PropCheck
   class Property
-    Configuration = Struct.new(:verbose, :n_runs, :max_generate_attempts, :max_shrink_steps, keyword_init: true) do
+    Configuration = Struct.new(
+      :verbose,
+      :n_runs,
+      :max_generate_attempts,
+      :max_shrink_steps,
+      :max_consecutive_attempts,
+      keyword_init: true) do
 
-      def initialize(verbose: false, n_runs: 1_000, max_generate_attempts: 10_000, max_shrink_steps: 10_000)
+      def initialize(
+            verbose: false,
+            n_runs: 1_000,
+            max_generate_attempts: 10_000,
+            max_shrink_steps: 10_000,
+            max_consecutive_attempts: 30
+          )
         super
       end
 

data/lib/prop_check/property/shrinker.rb

@@ -1,3 +1,4 @@
+require 'prop_check/helper'
 class PropCheck::Property::Shrinker
   def initialize(bindings_tree, io, hooks, config)
     @problem_child = bindings_tree
@@ -62,7 +63,7 @@ class PropCheck::Property::Shrinker
 
   private def safe_call_block(sibling, &block)
     begin
-      block.call(*sibling.root)
+      PropCheck::Helper.call_splatted(sibling.root, &block)
     # It is correct that we want to rescue _all_ Exceptions
     # not only 'StandardError's
     rescue Exception => e

data/lib/prop_check/version.rb

@@ -1,3 +1,3 @@
 module PropCheck
-  VERSION = '0.11.0'
+  VERSION = '0.11.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.11.1
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
@@ -83,7 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key:
 specification_version: 4
 summary: PropCheck allows you to do property-based testing, including shrinking.