prop_check 0.9.0

data/lib/prop_check/helper.rb

@@ -0,0 +1,27 @@
+module PropCheck
+  ##
+  # Helper functions that have no other place to live
+  module Helper
+    extend self
+    ##
+    # Creates a (potentially lazy) Enumerator
+    # starting with `elem`
+    # with each consecutive element obtained
+    # by calling `operation` on the previous element.
+    #
+    #   >> Helper.scanl(0, &:next).take(10).force
+    #   => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+    #   >> Helper.scanl([0, 1]) { |curr, next_elem| [next_elem, curr + next_elem] }.map(&:first).take(10).force
+    #   => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+    def scanl(elem, &operation)
+      Enumerator.new do |yielder|
+        acc = elem
+        loop do
+          # p acc
+          yielder << acc
+          acc = operation.call(acc)
+        end
+      end.lazy
+    end
+  end
+end

data/lib/prop_check/helper/lazy_append.rb

@@ -0,0 +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

data/lib/prop_check/lazy_tree.rb

@@ -0,0 +1,135 @@
+# 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
+
+    attr_accessor :root, :children
+    def initialize(root, children = [].lazy)
+      @root = root
+      @children = children
+    end
+
+    ##
+    # Maps `block` eagerly over `root` and lazily over `children`, returning a new LazyTree as result.
+    #
+    #   >> LazyTree.new(1, [LazyTree.new(2, [LazyTree.new(3)]), LazyTree.new(4)]).map(&:next).to_a
+    #   => LazyTree.new(2, [LazyTree.new(3, [LazyTree.new(4)]), LazyTree.new(5)]).to_a
+    def map(&block)
+      new_root = block.call(root)
+      new_children = children.map { |child_tree| child_tree.map(&block) }
+      LazyTree.new(new_root, new_children)
+    end
+
+    ##
+    # Turns a tree of trees
+    # in a single flattened tree, with subtrees that are closer to the root
+    # and the left subtree earlier in the list of children.
+    # TODO: Check for correctness
+    # def flatten
+    #   root_tree = root
+    #   root_root = root_tree.root
+
+    #   root_children = root_tree.children
+    #   flattened_children = children.map(&:flatten)
+
+    #   combined_children = root_children.lazy_append(flattened_children)
+
+    #   LazyTree.new(root_root, combined_children)
+    # end
+
+    def self.wrap(val)
+      LazyTree.new(val)
+    end
+
+    def bind(&fun)
+      inner_tree = fun.call(root)
+      inner_root = inner_tree.root
+      inner_children = inner_tree.children
+      mapped_children = children.map { |child| child.bind(&fun) }
+
+      combined_children = inner_children.lazy_append(mapped_children)
+
+      LazyTree.new(inner_root, combined_children)
+    end
+
+    ##
+    # Turns a LazyTree in a long lazy enumerable, with the root first followed by its children
+    # (and the first children's result before later children; i.e. a depth-first traversal.)
+    #
+    # Be aware that this lazy enumerable is potentially infinite,
+    # possibly uncountably so.
+    #
+    #   >> 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) }
+        [tree.root].lazy_append(new_children)
+      end
+
+      squish
+        .call(self, [])
+
+      # base = [root]
+      # recursive = children.map(&:each)
+      # res = base.lazy_append(recursive)
+
+      # return res.each(&block) if block_given?
+
+      # res
+
+      # res = [[root], children.flat_map(&:each)].lazy.flat_map(&:lazy)
+      # res = res.map(&block) if block_given?
+      # res
+    end
+
+    ##
+    # Fully evaluate the LazyTree into an eager array, with the root first followed by its children
+    # (and the first children's result before later children; i.e. a depth-first traversal.)
+    #
+    # Be aware that calling this might make Ruby attempt to evaluate an infinite collection.
+    # Therefore, it is mostly useful for debugging; in production you probably want to use
+    # the other mechanisms this class provides..
+    #
+    #   >> LazyTree.new(1, [LazyTree.new(2, [LazyTree.new(3)]), LazyTree.new(4)]).to_a
+    #   => [1, 4, 2, 3]
+    def to_a
+      each
+        .force
+    end
+
+    # TODO: fix implementation
+    def self.zip(trees)
+      # p "TREES: "
+      # p trees.to_a
+      # p "END TREES"
+      # raise "Boom!" unless trees.to_a.is_a?(Array) && trees.to_a.first.is_a?(LazyTree)
+      # p self
+      new_root = trees.to_a.map(&:root)
+      # p new_root
+      # new_children = trees.permutations.flat_map(&:children)
+      new_children = permutations(trees).map { |children| LazyTree.zip(children) }
+      # p new_children
+      LazyTree.new(new_root, new_children)
+    end
+
+    private_class_method def self.permutations(trees)
+      # p trees
+      trees.lazy.each_with_index.flat_map do |tree, index|
+        tree.children.map do |child|
+          child_trees = trees.to_a.clone
+          child_trees[index] = child
+          # p "CHILD TREES:"
+          # p child_trees
+          child_trees.lazy
+        end
+      end
+    end
+  end
+end

data/lib/prop_check/property.rb

@@ -0,0 +1,285 @@
+require 'stringio'
+require "awesome_print"
+
+require 'prop_check/property/configuration'
+module PropCheck
+  ##
+  # Run properties
+  class Property
+
+    ##
+    # 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(Generators.integer) do |val| ... end` and forall(Generators.integer).check do |val| ... end` are the same)
+    def self.forall(*bindings, &block)
+
+      property = new(*bindings)
+
+      return property.check(&block) if block_given?
+
+      property
+    end
+
+    ##
+    # Returns the default configuration of the library as it is configured right now
+    # for introspection.
+    #
+    # For the configuration of a single property, check its `configuration` instance method.
+    # See PropCheck::Property::Configuration for more info on available settings.
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    ##
+    # Yields the library's configuration object for you to alter.
+    # See PropCheck::Property::Configuration for more info on available settings.
+    def self.configure
+      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
+      @condition = proc { true }
+      @config = self.class.configuration
+    end
+
+    ##
+    # Returns the configuration of this property
+    # for introspection.
+    #
+    # See PropCheck::Property::Configuration for more info on available settings.
+    def configuration
+      @config
+    end
+
+    ##
+    # Allows you to override the configuration of this property
+    # by giving a hash with new settings.
+    #
+    # If no other changes need to occur before you want to check the property,
+    # 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)
+
+      return self.check(&block) if block_given?
+
+      self
+    end
+
+    ##
+    # filters the generator using the  given `condition`.
+    # The final property checking block will only be run if the condition is truthy.
+    #
+    # If wanted, multiple `where`-conditions can be specified on a property.
+    # Be aware that if you filter away too much generated inputs,
+    # 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 |**kwargs|
+        original_condition.call(**kwargs) && condition.call(**kwargs)
+      end
+
+      self
+    end
+
+    ##
+    # 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_enumerator(binding_generator).each do |generator_result|
+        n_runs += 1
+        check_attempt(generator_result, n_successful, &block)
+        n_successful += 1
+      end
+
+      ensure_not_exhausted!(n_runs)
+    end
+
+    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)
+        because too few generator results were adhering to
+        the `where` condition.
+
+        Try refining your generators instead.
+        """
+    end
+
+    private def check_attempt(generator_result, n_successful, &block)
+      block.call(*generator_result.root)
+
+    # immediately stop (without shrinnking) for when the app is asked
+    # to close by outside intervention
+    rescue SignalException, SystemExit
+      raise
+
+    # We want to capture _all_ exceptions (even low-level ones) here,
+    # so we can shrink to find their cause.
+    # don't worry: they all get reraised
+    rescue Exception => e
+      output, shrunken_result, shrunken_exception, n_shrink_steps = show_problem_output(e, generator_result, n_successful, &block)
+      output_string = output.is_a?(StringIO) ? output.string : e.message
+
+      e.define_singleton_method :prop_check_info do
+        {
+          original_input: generator_result.root,
+          original_exception_message: e.message,
+          shrunken_input: shrunken_result,
+          shrunken_exception: shrunken_exception,
+          n_successful: n_successful,
+          n_shrink_steps: n_shrink_steps
+        }
+      end
+
+      raise e, output_string, e.backtrace
+    end
+
+    private def attempts_enumerator(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.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)
+      shrunken_result, shrunken_exception, n_shrink_steps = shrink(generator_results, output, &block)
+      output = 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]
+    end
+  end
+end