prop_check 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb51503257a33dbe349da1b2b582be1c0fe38465bbe10fb14f610885591c9f7b
-  data.tar.gz: d357a2221e6b078c58d78826758cb22f4df3b8c34dd746001d854c505dfe2dea
+  metadata.gz: 013ca5101f31799feb0c86533c4100a781c451f937d6d8497a30476073e27e4b
+  data.tar.gz: f592ec086ca3018cfca1016baa1690619a5783274f02c910eb2ad03e5861a53d
 SHA512:
-  metadata.gz: 5d757c5c95b19cb3805ff1cc14af811fbb5e4f0cdb0cadffa581f46d33d20f2c37b8093fda66828b6ce3862b0743723ebb5afe01b183acc4bdbe6fc3f96ddb9b
-  data.tar.gz: e9288cedccdaafe609c2557a74176b9eea306fbff4aa2e9b9a4219702755efa33e53fb9f22d13f5ad0d7aa1af0dca732a1fe924d2119c43df39b71d1107be6d4
+  metadata.gz: f49b2514fe4e179013bd8c4a4683c1210b65d6852901156c6c5373f26305343fa4cae40860f13386a8f1fda33406927bf20a357f88cd5b99936318410837ba00
+  data.tar.gz: 261b980fb68c2d1af8baccb09919a838f91c1f6ae33f8c8a79923b2cb50490e4406e848ffbf6a75361d13d33719907a3342b4a7eed88ebdf37d1bdd8cd981ee4

data/.rubocop.yml

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

data/CHANGELOG.md

@@ -1,3 +1,4 @@
+- 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`

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)
@@ -146,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,
@@ -159,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
 
     ##
@@ -241,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))
@@ -252,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
 
-        tuple(*generators)
+    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
+
+    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
-        res.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
 
@@ -300,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
@@ -310,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
 
     ##
@@ -321,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
@@ -336,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
 
     ##
@@ -347,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",
@@ -375,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
 
     ##
@@ -386,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}"
@@ -406,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
 
     ##
@@ -417,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
@@ -443,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

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

@@ -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 self.check(&block) if block_given?
+      return duplicate.check(&block) if block_given?
 
-      self
+      duplicate
+    end
+
+    def with_bindings(*bindings, **kwbindings)
+      raise ArgumentError, 'No bindings specified!' if bindings.empty? && kwbindings.empty?
+
+      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
 
     ##
@@ -238,6 +264,8 @@ c.f. https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-k
     end
 
     private def attempts_enum(binding_generator)
+      ap @hooks
+
         @hooks
         .wrap_enum(raw_attempts_enum(binding_generator))
         .lazy

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.13.0'
+  VERSION = '0.14.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prop_check
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
 platform: ruby
 authors:
 - Qqwy/Wiebe-Marten Wijnja
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-03 00:00:00.000000000 Z
+date: 2020-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print