prop_check 0.11.1 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '099a3bafe1fae426f476e3add7fb93ab333506670c72c35bb78e5e505b9f0764'
-  data.tar.gz: d1c433ef97043f38c84a5bf8768fb46aa5fcc97f00518da831fbebc36142d2e5
+  metadata.gz: bd78cbcc636fbb2089c175708a6be52ebb8124b1f21758ee513f8a84fce33f97
+  data.tar.gz: d3bc244740e31fda8d3dbcdcafc3b7f2bd43676c13f945413bae852fbd82de6f
 SHA512:
-  metadata.gz: 782411f48a77c4bc2213d6ecaecd70d7d7c3609c13bab2125ce853dedd7d3029fd8801ac882154d8c924cea212698740d8e330f8e2b90f460a5a87484413e560
-  data.tar.gz: dd18135801b66e2f073e82066506f8bb26cf031a4bd8d2fc208864acd7ef3a7ec564f8364628d34e4ab40429a5444a1dbc41f329bb4c7d3a608011407bb0a923
+  metadata.gz: eda47d7e95d30de4a4b12fe18063b4eb234d7e2bafa2c071613c12c882e71a777da288504330990edde061a8247db33bdb8a7a829419b2111912b7499cef9749
+  data.tar.gz: d44b56680e431af41f2df178795a576d25ccf42e0fb2af086398a18a8b39ccb39eb071acfd88323705346ce5fd528361d3e049509d924be44300a9951d1260e3

data/.rubocop.yml

@@ -1,3 +1,5 @@
+AllCops:
+  TargetRubyVersion: 2.7
 Metrics/LineLength:
   Max: 120
 Style/AccessModifierDeclarations:

data/.travis.yml

@@ -3,7 +3,7 @@ sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5.1
+  - 2.6.5
 before_install: gem install bundler -v 2.0.2
 env:
   global:

data/CHANGELOG.md

@@ -1 +1,8 @@
-- 0.8.0 New syntax that is more explicit, passng generated values to blocks as parameters.
+- 0.14.1 - Swap `awesome_print` for `amazing_print` which is a fork of the former that is actively maintained.
+- 0.14.0 - Adds `uniq: true` option to `Generators.array`. Makes `PropCheck::Property` an immutable object that returns copies that have changes whenever reconfiguring, allowing re-usable configuration.
+- 0.13.0 - Adds Generator#resize
+- 0.12.1 - Fixes shrinking when filtering bug.
+- 0.12.0 - `PropCheck::Generators#instance`
+- 0.11.0 - Improved syntax to support Ruby 2.7 and up without deprecation warnings, full support for `#where`.
+- 0.10.0 - Some bugfixes, support for `#where`
+- 0.8.0 - New syntax that is more explicit, passng generated values to blocks as parameters.

data/README.md

@@ -24,10 +24,12 @@ Before releasing this gem on Rubygems, the following things need to be finished:
  - [x] Filtering generators. 
   - [x] Customize the max. of samples to run.
   - [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] 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.
+- [x] `#instance` generator to allow the easy creation of generators for custom datatypes.
+- [ ] A usage guide.
 
 # Nice-to-haves
  

data/bin/rspec

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "pathname"
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+bundle_binstub = File.expand_path("../bundle", __FILE__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300) =~ /This file was generated by Bundler/
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rspec-core", "rspec")

data/lib/prop_check/generator.rb

@@ -28,7 +28,9 @@ module PropCheck
 
       (0..max_consecutive_attempts).each do
         res = @block.call(**kwargs)
-        return res unless res.root == :"_PropCheck.filter_me"
+        next if res.root == :"_PropCheck.filter_me"
+
+        return res
       end
 
       raise Errors::GeneratorExhaustedError, """
@@ -118,5 +120,19 @@ module PropCheck
         end
       end
     end
+
+    ##
+    # Resizes the generator to either grow faster or smaller than normal.
+    #
+    # `proc` takes the current size as input and is expected to return the new size.
+    # a size should always be a nonnegative integer.
+    #
+    #    >> Generators.integer.resize{}
+    def resize(&proc)
+      Generator.new do |size:, **other_kwargs|
+        new_size = proc.call(size)
+        self.generate(**other_kwargs, size: new_size)
+      end
+    end
   end
 end

data/lib/prop_check/generators.rb

@@ -9,7 +9,7 @@ module PropCheck
   # Use this module by including it in the class (e.g. in your test suite)
   # where you want to use them.
   module Generators
-    extend self
+    module_function
 
     ##
     # Always returns the same value, regardless of `size` or `rng` (random number generator state)
@@ -82,11 +82,19 @@ module PropCheck
     #   => [-4205, -19140, 18158, -8716, -13735, -3150, 17194, 1962, -3977, -18315]
     def integer
       Generator.new do |size:, rng:, **|
+        ensure_proper_size!(size)
+
         val = rng.rand(-size..size)
         LazyTree.new(val, integer_shrink(val))
       end
     end
 
+    private def ensure_proper_size!(size)
+      return if size.is_a?(Integer) && size >= 0
+
+      raise ArgumentError, "`size:` should be a nonnegative integer but got `#{size.inspect}`"
+    end
+
     ##
     # Only returns integers that are zero or larger.
     # See `integer` for more information.
@@ -138,7 +146,7 @@ module PropCheck
       end
     end
 
-    @special_floats = [Float::NAN, Float::INFINITY, -Float::INFINITY, Float::MAX, Float::MIN, 0.0.next_float, 0.0.prev_float]
+    @@special_floats = [Float::NAN, Float::INFINITY, -Float::INFINITY, Float::MAX, Float::MIN, 0.0.next_float, 0.0.prev_float]
     ##
     # Generates floating-point numbers
     # Will generate NaN, Infinity, -Infinity,
@@ -151,7 +159,7 @@ module PropCheck
     #    >> Generators.float().sample(10, size: 10, rng: Random.new(42))
     #    => [4.0, 9.555555555555555, 0.0, -Float::INFINITY, 5.5, -5.818181818181818, 1.1428571428571428, 0.0, 8.0, 7.857142857142858]
     def float
-      frequency(99 => real_float, 1 => one_of(*@special_floats.map(&method(:constant))))
+      frequency(99 => real_float, 1 => one_of(*@@special_floats.map(&method(:constant))))
     end
 
     ##
@@ -233,6 +241,12 @@ module PropCheck
     # `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)
+    # `uniq:` When `true`, ensures that all elements in the array are unique.
+    #         When given a proc, uses the result of this proc to check for uniqueness.
+    #         (matching the behaviour of `Array#uniq`)
+    #         If it is not possible to generate another unique value after the configured `max_consecutive_attempts`
+    #         an `PropCheck::Errors::GeneratorExhaustedError` will be raised.
+    #         (default: `false`)
     #
     #
     #    >> Generators.array(Generators.positive_integer).sample(5, size: 1, rng: Random.new(42))
@@ -244,25 +258,68 @@ module PropCheck
     #    =>  [[], [2], [], [], [2]]
     #    >> Generators.array(Generators.positive_integer, empty: false).sample(5, size: 1, rng: Random.new(1))
     #    =>  [[2], [1], [2], [1], [1]]
+    #
+    #    >> Generators.array(Generators.boolean, uniq: true).sample(5, rng: Random.new(1))
+    #    => [[true, false], [false, true], [true, false], [false, true], [false, true]]
 
-
-    def array(element_generator, min: 0, max: nil, empty: true)
+    def array(element_generator, min: 0, max: nil, empty: true, uniq: false)
       min = 1 if min.zero? && !empty
+      uniq = proc { |x| x } if uniq == true
 
-      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
+      if max.nil?
+        nonnegative_integer.bind { |count| make_array(element_generator, min, count, uniq) }
+      else
+        make_array(element_generator, min, max, uniq)
+      end
+    end
+
+    private def make_array(element_generator, min, count, uniq)
+      amount = min if count < min
+      amount = min if count == min && min != 0
+      amount ||= (count - min)
+
+      # Simple, optimized implementation:
+      return make_array_simple(element_generator, amount) unless uniq
+
+      # More complex implementation that filters duplicates
+      make_array_uniq(element_generator, min, amount, uniq)
+    end
 
-        tuple(*generators)
+    private def make_array_simple(element_generator, amount)
+      generators = amount.times.map do
+        element_generator.clone
       end
 
-      if max.nil?
-        nonnegative_integer.bind(&res)
-      else
-        proc.call(max)
+      tuple(*generators)
+    end
+
+    private def make_array_uniq(element_generator, min, amount, uniq_fun)
+      Generator.new do |**kwargs|
+        arr = []
+        uniques = Set.new
+        count = 0
+        (0..).lazy.map do
+          elem = element_generator.clone.generate(**kwargs)
+          if uniques.add?(uniq_fun.call(elem.root))
+            arr.push(elem)
+            count = 0
+          else
+            count += 1
+          end
+
+          if count > kwargs[:max_consecutive_attempts]
+            if arr.size >= min
+              # Give up and return shorter array in this case
+              amount = min
+            else
+              raise Errors::GeneratorExhaustedError, "Too many consecutive elements filtered by 'uniq:'."
+            end
+          end
+        end
+        .take_while { arr.size < amount }
+        .force
+
+        LazyTree.zip(arr).map { |array| array.uniq(&uniq_fun) }
       end
     end
 
@@ -292,7 +349,7 @@ module PropCheck
         .map(&:to_h)
     end
 
-    @alphanumeric_chars = [('a'..'z'), ('A'..'Z'), ('0'..'9')].flat_map(&:to_a).freeze
+    @@alphanumeric_chars = [('a'..'z'), ('A'..'Z'), ('0'..'9')].flat_map(&:to_a).freeze
     ##
     # Generates a single-character string
     # containing one of a..z, A..Z, 0..9
@@ -302,7 +359,7 @@ module PropCheck
     #    >> Generators.alphanumeric_char.sample(5, size: 10, rng: Random.new(42))
     #    => ["M", "Z", "C", "o", "Q"]
     def alphanumeric_char
-      one_of(*@alphanumeric_chars.map(&method(:constant)))
+      one_of(*@@alphanumeric_chars.map(&method(:constant)))
     end
 
     ##
@@ -313,11 +370,13 @@ module PropCheck
     #
     #    >> Generators.alphanumeric_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["ZCoQ", "8uM", "wkkx0JNx", "v0bxRDLb", "Gl5v8RyWA6"]
+    #
+    # Accepts the same options as `array`
     def alphanumeric_string(**kwargs)
       array(alphanumeric_char, **kwargs).map(&:join)
     end
 
-    @printable_ascii_chars = (' '..'~').to_a.freeze
+    @@printable_ascii_chars = (' '..'~').to_a.freeze
 
     ##
     # Generates a single-character string
@@ -328,7 +387,7 @@ module PropCheck
     #   >> Generators.printable_ascii_char.sample(size: 10, rng: Random.new(42))
     #   => ["S", "|", ".", "g", "\\", "4", "r", "v", "j", "j"]
     def printable_ascii_char
-      one_of(*@printable_ascii_chars.map(&method(:constant)))
+      one_of(*@@printable_ascii_chars.map(&method(:constant)))
     end
 
     ##
@@ -339,12 +398,14 @@ module PropCheck
     #
     #    >> Generators.printable_ascii_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["S|.g", "rvjjw7\"5T!", "=", "!_[4@", "Y"]
+    #
+    # Accepts the same options as `array`
     def printable_ascii_string(**kwargs)
       array(printable_ascii_char, **kwargs).map(&:join)
     end
 
-    @ascii_chars = [
-      @printable_ascii_chars,
+    @@ascii_chars = [
+      @@printable_ascii_chars,
       [
         "\n",
         "\r",
@@ -367,7 +428,7 @@ module PropCheck
     #    >> Generators.ascii_char.sample(size: 10, rng: Random.new(42))
     #    => ["d", "S", "|", ".", "g", "\\", "4", "d", "r", "v"]
     def ascii_char
-      one_of(*@ascii_chars.map(&method(:constant)))
+      one_of(*@@ascii_chars.map(&method(:constant)))
     end
 
     ##
@@ -378,12 +439,14 @@ 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"]
+    #
+    # Accepts the same options as `array`
     def ascii_string(**kwargs)
       array(ascii_char, **kwargs).map(&:join)
     end
 
-    @printable_chars = [
-      @ascii_chars,
+    @@printable_chars = [
+      @@ascii_chars,
       "\u{A0}".."\u{D7FF}",
       "\u{E000}".."\u{FFFD}",
       "\u{10000}".."\u{10FFFF}"
@@ -398,7 +461,7 @@ module PropCheck
     #    >> Generators.printable_char.sample(size: 10, rng: Random.new(42))
     #    => ["吏", "", "", "", "", "", "", "", "", "Ȍ"]
     def printable_char
-      one_of(*@printable_chars.map(&method(:constant)))
+      one_of(*@@printable_chars.map(&method(:constant)))
     end
 
     ##
@@ -409,6 +472,8 @@ module PropCheck
     #
     #    >> Generators.printable_string.sample(5, size: 10, rng: Random.new(42))
     #    => ["", "Ȍ", "𐁂", "Ȕ", ""]
+    #
+    # Accepts the same options as `array`
     def printable_string(**kwargs)
       array(printable_char, **kwargs).map(&:join)
     end
@@ -435,6 +500,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}"]
+    #
+    # Accepts the same options as `array`
     def string(**kwargs)
       array(char, **kwargs).map(&:join)
     end
@@ -520,5 +587,44 @@ module PropCheck
     def nillable(other_generator)
       frequency(9 => other_generator, 1 => constant(nil))
     end
+
+    ##
+    # Generates an instance of `klass`
+    # using `args` and/or `kwargs`
+    # as generators for the arguments that are passed to `klass.new`
+    #
+    # ## Example:
+    #
+    # Given a class like this:
+    #
+    #
+    #    class User
+    #      attr_accessor :name, :age
+    #      def initialize(name: , age: )
+    #        @name = name
+    #        @age = age
+    #      end
+    #
+    #      def inspect
+    #        "<User name: #{@name.inspect}, age: #{@age.inspect}>"
+    #      end
+    #    end
+    #
+    #   >> user_gen = Generators.instance(User, name: Generators.printable_ascii_string, age: Generators.nonnegative_integer)
+    #   >> user_gen.sample(3, rng: Random.new(42)).inspect
+    #   => "[<User name: \"S|.g\", age: 10>, <User name: \"rvjj\", age: 10>, <User name: \"7\\\"5T!w=\", age: 5>]"
+    def instance(klass, *args, **kwargs)
+      tuple(*args).bind do |vals|
+        fixed_hash(**kwargs).map do |kwvals|
+          if kwvals == {}
+            klass.new(*vals)
+          elsif vals == []
+            klass.new(**kwvals)
+          else
+            klass.new(*vals, **kwvals)
+          end
+        end
+      end
+    end
   end
 end

data/lib/prop_check/hooks.rb

@@ -19,10 +19,11 @@
 # 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) }
+  def initialize(before: proc {}, after: proc {}, around: proc { |*args, &block| block.call(*args) })
+    @before = before
+    @after = after
+    @around = around
+    freeze
   end
 
   def wrap_enum(enumerable)
@@ -59,34 +60,40 @@ class PropCheck::Hooks
   # 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
+    # old_before = @before
+    new_before = proc {
+      @before.call
       hook.call
     }
+    # self
+    self.class.new(before: new_before, after: @after, around: @around)
   end
 
   ##
   # Adds `hook` to the `after` proc.
   # It is called before earlier-added `after` procs.
   def add_after(&hook)
-    old_after = @after
-    @after = proc {
+    # old_after = @after
+    new_after = proc {
       hook.call
-      old_after.call
+      @after.call
     }
+    # self
+    self.class.new(before: @before, after: new_after, around: @around)
   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|
+    # old_around = @around
+    new_around = proc do |&block|
+      @around.call do |*args|
         hook.call(*args, &block)
       end
     end
+    # self
+    self.class.new(before: @before, after: @after, around: new_around)
   end
 
   ##

data/lib/prop_check/lazy_tree.rb

@@ -9,12 +9,16 @@ module PropCheck
 
     include Enumerable
 
-    attr_accessor :root, :children
+    attr_accessor :root
     def initialize(root, children = [].lazy)
       @root = root
       @children = children
     end
 
+    def children
+      @children.reject { |child| child.root == :"_PropCheck.filter_me" }
+    end
+
     ##
     # Maps `block` eagerly over `root` and lazily over `children`, returning a new LazyTree as result.
     #
@@ -121,5 +125,6 @@ module PropCheck
         end
       end
     end
+
   end
 end

data/lib/prop_check/property.rb

@@ -1,5 +1,5 @@
 require 'stringio'
-require "awesome_print"
+require 'amazing_print'
 
 require 'prop_check/property/configuration'
 require 'prop_check/property/output_formatter'
@@ -7,9 +7,15 @@ require 'prop_check/property/shrinker'
 require 'prop_check/hooks'
 module PropCheck
   ##
-  # Run properties
+  # Create and run property-checks.
+  #
+  # For simple usage, see `.forall`.
+  #
+  # For advanced usage, call `PropCheck::Property.new(...)` and then configure it to your liking
+  # using e.g. `#with_config`, `#before`, `#after`, `#around` etc.
+  # Each of these methods will return a new `Property`, so earlier properties are not mutated.
+  # This allows you to re-use configuration and hooks between multiple tests.
   class Property
-
     ##
     # Main entry-point to create (and possibly immediately run) a property-test.
     #
@@ -36,7 +42,6 @@ module PropCheck
     # 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, **kwbindings, &block)
-
       property = new(*bindings, **kwbindings)
 
       return property.check(&block) if block_given?
@@ -61,19 +66,25 @@ module PropCheck
       yield(configuration)
     end
 
-    attr_reader :bindings, :condition
-
     def initialize(*bindings, **kwbindings)
-      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
-
-      # @bindings = bindings
-      # @kwbindings = kwbindings
-      @gen = gen_from_bindings(bindings, kwbindings)
-      @condition = proc { true }
       @config = self.class.configuration
       @hooks = PropCheck::Hooks.new
+
+      @gen = gen_from_bindings(bindings, kwbindings) unless bindings.empty? && kwbindings.empty?
+      freeze
     end
 
+    # [:condition, :config, :hooks, :gen].each do |symbol|
+    #   define_method(symbol) do
+    #     self.instance_variable_get("@#{symbol}")
+    #   end
+
+    #   protected define_method("#{symbol}=") do |value|
+    #     duplicate = self.dup
+    #     duplicate.instance_variable_set("@#{symbol}", value)
+    #     duplicate
+    #   end
+
     ##
     # Returns the configuration of this property
     # for introspection.
@@ -91,11 +102,22 @@ module PropCheck
     # you can immediately pass a block to this method.
     # (so `forall(a: Generators.integer).with_config(verbose: true) do ... end` is the same as `forall(a: Generators.integer).with_config(verbose: true).check do ... end`)
     def with_config(**config, &block)
-      @config = @config.merge(config)
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@config, @config.merge(config))
+      duplicate.freeze
+
+      return duplicate.check(&block) if block_given?
+
+      duplicate
+    end
 
-      return self.check(&block) if block_given?
+    def with_bindings(*bindings, **kwbindings)
+      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
 
-      self
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@gen, gen_from_bindings(bindings, kwbindings))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -107,14 +129,12 @@ 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 |val|
-      #   call_splatted(val, &original_condition) && call_splatted(val, &condition)
-      #   # original_condition.call(val) && condition.call(val)
-      # end
-      @gen = @gen.where(&condition)
-
-      self
+      raise ArgumentError, 'No generator bindings specified! #where should be called after `#forall` or `#with_bindings`.' unless @gen
+
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@gen, @gen.where(&condition))
+      duplicate.freeze
+      duplicate
     end
 
 
@@ -124,8 +144,10 @@ module PropCheck
     # 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
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_before(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -134,8 +156,10 @@ module PropCheck
     # 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
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_after(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##
@@ -152,8 +176,10 @@ module PropCheck
     # 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
+      duplicate = self.dup
+      duplicate.instance_variable_set(:@hooks, @hooks.add_around(&hook))
+      duplicate.freeze
+      duplicate
     end
 
     ##

data/lib/prop_check/property/configuration.rb

@@ -10,7 +10,7 @@ module PropCheck
 
       def initialize(
             verbose: false,
-            n_runs: 1_000,
+            n_runs: 100,
             max_generate_attempts: 10_000,
             max_shrink_steps: 10_000,
             max_consecutive_attempts: 30

data/lib/prop_check/version.rb

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

data/prop_check.gemspec

@@ -36,5 +36,5 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.5.1'
 
-  spec.add_dependency 'awesome_print', '~> 1.8'
+  spec.add_dependency 'amazing_print', '~> 1.2'
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.11.1
+  version: 0.14.1
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-02 00:00:00.000000000 Z
+date: 2020-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: awesome_print
+  name: amazing_print
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.2'
 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
@@ -47,6 +47,7 @@ files:
 - README.md
 - Rakefile
 - bin/console
+- bin/rspec
 - bin/setup
 - lib/prop_check.rb
 - lib/prop_check/generator.rb