rantly 0.2.0 → 3.0.0

data/lib/rantly/generator.rb

@@ -1,7 +1,7 @@
 class Rantly
-
   class << self
     attr_writer :default_size
+
     def singleton
       @singleton ||= Rantly.new
       @singleton
@@ -11,20 +11,20 @@ class Rantly
       @default_size || 6
     end
 
-    def each(n,limit=10,&block)
-      gen.each(n,limit,&block)
+    def each(n, limit = 10, &block)
+      gen.each(n, limit, &block)
     end
 
-    def map(n,limit=10,&block)
-      gen.map(n,limit,&block)
+    def map(n, limit = 10, &block)
+      gen.map(n, limit, &block)
     end
 
-    def value(limit=10,&block)
-      gen.value(limit,&block)
+    def value(limit = 10, &block)
+      gen.value(limit, &block)
     end
-    
+
     def gen
-      self.singleton
+      singleton
     end
   end
 
@@ -32,8 +32,7 @@ class Rantly
   end
 
   class TooManyTries < RuntimeError
-    
-    def initialize(limit,nfailed)
+    def initialize(limit, nfailed)
       @limit = limit
       @nfailed = nfailed
     end
@@ -42,38 +41,37 @@ class Rantly
       @nfailed
     end
 
-    def to_s
-      "Exceed gen limit #{@limit}: #{@nfailed} failed guards)"
-    end
+    attr_reader :limit
   end
 
   # limit attempts to 10 times of how many things we want to generate
-  def each(n,limit=10,&block)
-    generate(n,limit,block)
+  def each(n, limit = 10, &block)
+    generate(n, limit, block)
   end
 
-  def map(n,limit=10,&block)
+  def map(n, limit = 10, &block)
     acc = []
-    generate(n,limit,block) do |val|
+    generate(n, limit, block) do |val|
       acc << val
     end
     acc
   end
 
-  def value(limit=10,&block)
-    generate(1,limit,block) do |val|
+  def value(limit = 10, &block)
+    generate(1, limit, block) do |val|
       return val
     end
   end
 
-  def generate(n,limit_arg,gen_block,&handler)
+  def generate(n, limit_arg, gen_block, &handler)
     limit = n * limit_arg
     nfailed = 0
     nsuccess = 0
     while nsuccess < n
-      raise TooManyTries.new(limit_arg*n,nfailed) if limit < 0
+      raise TooManyTries.new(limit_arg * n, nfailed) if limit.zero?
+
       begin
-        val = self.instance_eval(&gen_block)
+        val = instance_eval(&gen_block)
       rescue GuardFailure
         nfailed += 1
         limit -= 1
@@ -81,10 +79,10 @@ class Rantly
       end
       nsuccess += 1
       limit -= 1
-      handler.call(val) if handler
+      yield(val) if handler
     end
   end
-  
+
   attr_accessor :classifiers
 
   def initialize
@@ -101,73 +99,89 @@ class Rantly
   end
 
   def guard(test)
-    raise GuardFailure.new unless test
+    return true if test
+
+    raise GuardFailure
   end
 
   def size
     @size || Rantly.default_size
   end
-  
-  def sized(n,&block)
-    raise "size needs to be greater than zero" if n < 0
+
+  def sized(n, &block)
+    raise 'size needs to be greater than zero' if n.negative?
+
     old_size = @size
     @size = n
-    r = self.instance_eval(&block)
+    r = instance_eval(&block)
     @size = old_size
-    return r
+    r
   end
 
   # wanna avoid going into Bignum when calling range with these.
-  INTEGER_MAX = (2**(0.size * 8 -2) -1) / 2
-  INTEGER_MIN = -(INTEGER_MAX)
-  def integer(limit=nil)
+  INTEGER_MAX = (2**(0.size * 8 - 2) - 1) / 2
+  INTEGER_MIN = -INTEGER_MAX
+  def integer(limit = nil)
     case limit
     when Range
       hi = limit.end
       lo = limit.begin
     when Integer
-      raise "n should be greater than zero" if limit < 0
-      hi, lo = limit, -limit
+      raise 'n should be greater than zero' if limit.negative?
+
+      hi = limit
+      lo = -limit
     else
-      hi, lo = INTEGER_MAX, INTEGER_MIN
+      hi = INTEGER_MAX
+      lo = INTEGER_MIN
     end
-    range(lo,hi)
+    range(lo, hi)
   end
 
   def positive_integer
     range(0)
   end
 
-  def float
-    rand
+  def float(distribution = nil, params = {})
+    case distribution
+    when :normal
+      params[:center] ||= 0
+      params[:scale] ||= 1
+      raise 'The distribution scale should be greater than zero' if params[:scale].negative?
+
+      # Sum of 6 draws from a uniform distribution give as a draw of a normal
+      # distribution centered in 3 (central limit theorem).
+      ([rand, rand, rand, rand, rand, rand].sum - 3) * params[:scale] + params[:center]
+    else
+      rand
+    end
   end
 
-  def range(lo=nil,hi=nil)
-    lo ||= INTEGER_MIN
-    hi ||= INTEGER_MAX
-    rand(hi+1-lo) + lo
+  def range(lo = INTEGER_MIN, hi = INTEGER_MAX)
+    rand(lo..hi)
   end
 
-  def call(gen,*args)
+  def call(gen, *args)
     case gen
     when Symbol
-      return self.send(gen,*args)
+      send(gen, *args)
     when Array
-      raise "empty array" if gen.empty?
-      return self.send(gen[0],*gen[1..-1])
+      raise 'empty array' if gen.empty?
+
+      send(gen[0], *gen[1..-1])
     when Proc
-      return self.instance_eval(&gen)
+      instance_eval(&gen)
     else
       raise "don't know how to call type: #{gen}"
     end
   end
 
   def branch(*gens)
-    self.call(choose(*gens))
+    call(choose(*gens))
   end
 
   def choose(*vals)
-    vals[range(0,vals.length-1)]
+    vals[range(0, vals.length - 1)] if vals.length.positive?
   end
 
   def literal(value)
@@ -175,99 +189,99 @@ class Rantly
   end
 
   def boolean
-    range(0,1) == 0 ? true : false
+    range(0, 1).zero?
   end
 
   def freq(*pairs)
     pairs = pairs.map do |pair|
       case pair
       when Symbol, String, Proc
-        [1,pair]
+        [1, pair]
       when Array
-        unless pair.first.is_a?(Integer)
-          [1] + pair
-        else
+        if pair.first.is_a?(Integer)
           pair
+        else
+          [1] + pair
         end
       end
     end
-    total = pairs.inject(0) { |sum,p| sum + p.first }
-    raise(RuntimeError, "Illegal frequency:#{pairs.inspect}") if total == 0
-    pos = range(1,total)
+    total = pairs.inject(0) { |sum, p| sum + p.first }
+    raise("Illegal frequency:#{pairs.inspect}") if total.zero?
+
+    pos = range(1, total)
     pairs.each do |p|
       weight, gen, *args = p
-      if pos <= p[0]
-        return self.call(gen,*args)
-      else
-        pos -= weight
-      end
+      return call(gen, *args) if pos <= p[0]
+
+      pos -= weight
     end
   end
 
-  def array(*freq_pairs)
-    acc = []
-    self.size.times { acc << freq(*freq_pairs) }
-    acc
+  def array(n = size, &block)
+    n.times.map { instance_eval(&block) }
+  end
+
+  def dict(n = size, &block)
+    h = {}
+    each(n) do
+      k, v = instance_eval(&block)
+      h[k] = v if guard(!h.key?(k))
+    end
+    h
   end
 
   module Chars
-    
     class << self
-      ASCII = ""
-      (0..127).to_a.each do |i|
-        ASCII << i
-      end
+      ASCII = (0..127).to_a.each_with_object('') { |i, obj| obj << i }
 
       def of(regexp)
-        ASCII.scan(regexp).to_a.map! { |char| char[0] }
+        ASCII.scan(regexp).to_a.map! { |char| char[0].ord }
       end
     end
-    
-    ALNUM = Chars.of /[[:alnum:]]/
-    ALPHA = Chars.of /[[:alpha:]]/
-    BLANK = Chars.of /[[:blank:]]/
-    CNTRL = Chars.of /[[:cntrl:]]/
-    DIGIT = Chars.of /[[:digit:]]/
-    GRAPH = Chars.of /[[:graph:]]/
-    LOWER = Chars.of /[[:lower:]]/
-    PRINT = Chars.of /[[:print:]]/
-    PUNCT = Chars.of /[[:punct:]]/
-    SPACE = Chars.of /[[:space:]]/
-    UPPER = Chars.of /[[:upper:]]/
-    XDIGIT = Chars.of /[[:xdigit:]]/
-    ASCII = Chars.of /./
-    
-    
+
+    ALNUM = Chars.of(/[[:alnum:]]/)
+    ALPHA = Chars.of(/[[:alpha:]]/)
+    BLANK = Chars.of(/[[:blank:]]/)
+    CNTRL = Chars.of(/[[:cntrl:]]/)
+    DIGIT = Chars.of(/[[:digit:]]/)
+    GRAPH = Chars.of(/[[:graph:]]/)
+    LOWER = Chars.of(/[[:lower:]]/)
+    PRINT = Chars.of(/[[:print:]]/)
+    PUNCT = Chars.of(/[[:punct:]]/)
+    SPACE = Chars.of(/[[:space:]]/)
+    UPPER = Chars.of(/[[:upper:]]/)
+    XDIGIT = Chars.of(/[[:xdigit:]]/)
+    ASCII = Chars.of(/./)
+
     CLASSES = {
-      :alnum => ALNUM,
-      :alpha => ALPHA,
-      :blank => BLANK,
-      :cntrl => CNTRL,
-      :digit => DIGIT,
-      :graph => GRAPH,
-      :lower => LOWER,
-      :print => PRINT,
-      :punct => PUNCT,
-      :space => SPACE,
-      :upper => UPPER,
-      :xdigit => XDIGIT,
-      :ascii => ASCII,
-    }
-    
+      alnum: ALNUM,
+      alpha: ALPHA,
+      blank: BLANK,
+      cntrl: CNTRL,
+      digit: DIGIT,
+      graph: GRAPH,
+      lower: LOWER,
+      print: PRINT,
+      punct: PUNCT,
+      space: SPACE,
+      upper: UPPER,
+      xdigit: XDIGIT,
+      ascii: ASCII
+    }.freeze
   end
 
-  def string(char_class=:print)
+  def string(char_class = :print)
     chars = case char_class
             when Regexp
               Chars.of(char_class)
             when Symbol
               Chars::CLASSES[char_class]
             end
-    raise "bad arg" unless chars
-    str = ""
-    size.times do
-      str << choose(*chars)
-    end
-    str
+    raise 'bad arg' unless chars
+
+    char_strings = chars.map(&:chr)
+    str = Array.new(size)
+    size.times { |i| str[i] = char_strings.sample }
+    str.join
   end
 end

data/lib/rantly/minitest.rb

@@ -0,0 +1 @@
+require 'rantly/minitest_extensions'

data/lib/rantly/minitest_extensions.rb

@@ -0,0 +1,15 @@
+require 'minitest'
+require 'rantly/property'
+require "minitest/unit" unless defined?(MiniTest)
+
+test_class = if defined?(MiniTest::Test)
+               MiniTest::Test
+             else
+               MiniTest::Unit::TestCase
+             end
+
+test_class.class_eval do
+  def property_of(&blk)
+    Rantly::Property.new(blk)
+  end
+end

data/lib/rantly/property.rb

@@ -1,50 +1,81 @@
 require 'rantly'
-require 'test/unit'
 require 'pp'
+require 'stringio'
 
 class Rantly::Property
+  attr_reader :failed_data, :shrunk_failed_data
+
+  VERBOSITY = ENV.fetch('RANTLY_VERBOSE', 1).to_i
+  RANTLY_COUNT = ENV.fetch('RANTLY_COUNT', 100).to_i
+
+  def io
+    @io ||= if VERBOSITY >= 1
+              $stdout
+            else
+              StringIO.new
+            end
+  end
+
+  def pretty_print(object)
+    PP.pp(object, io)
+  end
 
   def initialize(property)
     @property = property
   end
-  
-  def check(n=100,limit=10,&assertion)
+
+  def check(n = RANTLY_COUNT, limit = 10, &assertion)
     i = 0
     test_data = nil
     begin
-      Rantly.singleton.generate(n,limit,@property) do |val|
+      Rantly.singleton.generate(n, limit, @property) do |val|
         test_data = val
-        assertion.call(val) if assertion
-        puts "" if i % 100 == 0
-        print "." if i % 10 == 0
+        yield(val) if assertion
+        io.puts '' if (i % 100).zero?
+        io.print '.' if (i % 10).zero?
         i += 1
       end
-      puts
-      puts "success: #{i} tests"
+      io.puts
+      io.puts "SUCCESS - #{i} successful tests"
     rescue Rantly::TooManyTries => e
-      puts
-      puts "too many tries: #{e.tries}"
-      raise e
-    rescue => boom
-      puts
-      puts "failure: #{i} tests, on:"
-      pp test_data
-      raise boom
+      io.puts
+      io.puts "FAILURE - #{i} successful tests, too many tries: #{e.tries}"
+      raise e.exception("#{i} successful tests, too many tries: #{e.tries} (limit: #{e.limit})")
+    rescue Exception => e
+      io.puts
+      io.puts "FAILURE - #{i} successful tests, failed on:"
+      pretty_print test_data
+      @failed_data = test_data
+      if @failed_data.respond_to?(:shrink)
+        @shrunk_failed_data, @depth = shrinkify(assertion, @failed_data)
+        io.puts "Minimal failed data (depth #{@depth}) is:"
+        pretty_print @shrunk_failed_data
+      end
+      raise e.exception("#{i} successful tests, failed on:\n#{test_data}\n\n#{e}\n")
     end
   end
 
-  def report
-    distribs = self.classifiers.sort { |a,b| b[1] <=> a[1] }
-    total = distribs.inject(0) { |sum,pair| sum + pair[1]}
-    distribs.each do |(classifier,count)|
-      format "%10.5f%% of => %s", count, classifier
+  # Explore the failures tree
+  def shrinkify(assertion, data, depth = 0, iteration = 0)
+    min_data = data
+    max_depth = depth
+    if data.shrinkable?
+      while iteration < 1024
+        # We assume that data.shrink is non-destructive
+        shrunk_data = data.shrink
+        begin
+          assertion.call(shrunk_data)
+        rescue Exception
+          # If the assertion was verified, recursively shrink failure case
+          branch_data, branch_depth, iteration = shrinkify(assertion, shrunk_data, depth + 1, iteration + 1)
+          if branch_depth > max_depth
+            min_data = branch_data
+            max_depth = branch_depth
+          end
+        end
+        break unless data.retry?
+      end
     end
+    [min_data, max_depth, iteration]
   end
 end
-
-module Test::Unit::Assertions
-  def property_of(&block)
-    Rantly::Property.new(block)
-  end
-end
-

data/lib/rantly/rspec.rb

@@ -0,0 +1 @@
+require 'rantly/rspec_extensions'

data/lib/rantly/rspec_extensions.rb

@@ -0,0 +1,8 @@
+require 'rspec/core'
+require 'rantly/property'
+
+class RSpec::Core::ExampleGroup
+  def property_of(&block)
+    Rantly::Property.new(block)
+  end
+end