rantly 1.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79dd7dec8dc33c88121e8f18e937c066730f92d190e34657742245d5d2ad39ce
-  data.tar.gz: 0d0a1435d25e7ad2d1948d45040a6524b79425011289331484b35b0387d7d750
+  metadata.gz: 406db7ec111ce8f3580b6f76970b4baf110bae5926a5cc476f55ee435d857b4a
+  data.tar.gz: 5e42ee8b71cd692f7cd330fce8e3b65807ee9405afeb5ef2a847111da8ebefea
 SHA512:
-  metadata.gz: 7f652b90718f7d9f32c1e88995d85371cd87af8d247b7def676a171b58f170cb08d0d29f54cb68259a7f4f42c64299d7c1b8f1741095c9dc174e4208904535b0
-  data.tar.gz: 54a9a7f6c94741379d58268fb56a0fb47e8787868e5f8610904a2c551d65041e6042470a3a3514acd0a585a2e75859b26f73605b0a55e5352f0a913a83b4742c
+  metadata.gz: d83625897b4e83a7fed19c07922d2f456e14e69f86d56fdc0d13e7e0651ac71f28d897f2208815c383e602c7ab2093c3e28b33fd9b9eb957869764d117009c7a
+  data.tar.gz: d2362962331c07a90c37622ef9cef880de4cbb982daa04cc4cf5c38b178202616b6637527d03249e6941beeab588a57329fc982a09237041bdb231bbca467c9a

data/.travis.yml

@@ -4,10 +4,13 @@ cache: bundler
 after_success:
   - coveralls
 rvm:
-    - 2.0.0
-    - 2.1.9
-    - 2.2.6
-    - 2.3.3
     - 2.4.0
-    - jruby-1.7.26
-    - jruby-9.1.7.0
+    - 2.5.1
+    - ruby-head
+    - jruby-9.2.0.0
+    - jruby-head
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head
+    - rvm: ruby-head

data/CHANGELOG.md

@@ -3,6 +3,38 @@ All notable changes to rantly will be documented in this file. The curated log b
 
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [Master](https://github.com/rantly-rb/rantly/compare/2.0.0...master) (unreleased)
+
+### New features
+
+### Bug fixes
+
+### Changes
+
+
+## [2.0.0](https://github.com/rantly-rb/rantly/compare/1.2.0...2.0.0) - 2019-01-08
+
+### New features
+- Add support for float ranges to `range` generator
+  - [Issue #60](https://github.com/rantly-rb/rantly/issues/60)
+  - thanks [Trevor Brown][Trevor Brown]
+
+### Bug fixes
+- `range` generator returns `nil` for invalid ranges
+  - [Issue #60](https://github.com/rantly-rb/rantly/issues/60)
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+- `choose` generator returns `nil` when no values are given
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+
+### Changes
+- Only support for Ruby >= 2.4 and JRuby >= 9.2
+  - [Issue #42](https://github.com/rantly-rb/rantly/issues/42) and [issue #37](https://github.com/rantly-rb/rantly/issues/37)
+- Do not render all shrinking levels, only the failing case and the minimal failed data.
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+- Improve failure/success messages
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+
+
 ## [1.2.0](https://github.com/abargnesi/rantly/compare/1.1.0...1.2.0) - 2018-08-29
 ### New features
 - Allow to generate floats using Gaussian distribution
@@ -59,3 +91,4 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 [Oleksii Fedorov]:          https://github.com/waterlink
 [Ana María Martínez Gómez]: https://github.com/Ana06
 [Víctor Gallego]:           https://github.com/vicgalle
+[Trevor Brown]:             https://github.com/Stratus3D

data/Gemfile

@@ -1,8 +1,11 @@
 source 'https://rubygems.org'
 
 group :development, :test do
-  gem 'rake',      '~> 12.0.0'
+  gem 'coveralls', '>= 0', require: false
   gem 'minitest',  '~> 5.10.0'
+  gem 'rake',      '~> 12.3.3'
   gem 'simplecov', '>= 0'
-  gem 'coveralls', '>= 0', :require => false
+
+  gem 'rubocop'
+  gem 'rubocop-performance', require: false
 end

data/README.md

@@ -1,5 +1,6 @@
 [![Gem version](https://badge.fury.io/rb/rantly.svg)](https://badge.fury.io/rb/rantly)
 [![Build Status](https://travis-ci.org/rantly-rb/rantly.svg?branch=master)](https://travis-ci.org/rantly-rb/rantly)
+[![Coverage Status](https://coveralls.io/repos/github/rantly-rb/rantly/badge.svg?branch=master)](https://coveralls.io/github/rantly-rb/rantly?branch=master)
 
 # Imperative Random Data Generator and Quickcheck
 
@@ -9,13 +10,19 @@ Rantly is basically a recursive descent interpreter, each of its method returns
 
 Its implementation has no alien mathematics inside. Completely side-effect-free-free.
 
+![img](/logo/Rantly.png)
+
 
 # Install
 
+Rantly requires Ruby 3.2 or higher. To install Rantly add it to your Gemfile or run:
+
 ```ruby
 $ gem install rantly
 ```
 
+You can try it in the console by running:
+
 ```ruby
 $ irb -rrantly
 > Rantly { [integer,float] } # same as Rantly.value { integer }
@@ -401,8 +408,10 @@ Normal arrays or hashes are not shrinked.
 
 Thanks to [all contributors](https://github.com/rantly-rb/rantly/graphs/contributors). :cupid: New contributors are welcome! :wink:
 
+[Logotype](/logo) designed by: [@Richardbmx](https://github.com/richardbmx)
+
 
 # License
 
-Code published under MIT License, Copyright (c) 2009 Howard Yeh. See [LICENSE](https://github.com/abargnesi/rantly/LICENSE).
+Code published under MIT License, Copyright (c) 2009 Howard Yeh. See [LICENSE](/LICENSE).
 

data/Rakefile

@@ -1,22 +1,35 @@
 require 'rake'
 
+task default: %i[test rubocop]
+
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
 
-task :default => :test
+require 'rubocop/rake_task'
+
+desc 'Run RuboCop'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--display-cop-names']
+end
+
+RuboCop::RakeTask.new('rubocop:auto_gen_config') do |task|
+  task.options = ['--display-cop-names', '--auto-gen-config', '--auto-gen-only-exclude']
+end
 
 require 'rdoc/task'
+
 Rake::RDocTask.new do |rdoc|
   require 'yaml'
   if File.exist?('VERSION.yml')
     config = YAML.load(File.read('VERSION.yml'))
     version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
   else
-    version = ""
+    version = ''
   end
 
   rdoc.rdoc_dir = 'rdoc'

data/VERSION.yml

@@ -1,5 +1,5 @@
---- 
-:build: 
-:major: 1
-:minor: 2
+---
+:build:
+:major: 3
+:minor: 0
 :patch: 0

data/lib/rantly/data.rb

@@ -1,6 +1,6 @@
 module Rantly::Data
   def email
-    "#{string(:alnum)}@#{string(:alnum)}.#{sized(3){string(:alpha)}}".downcase
+    "#{string(:alnum)}@#{string(:alnum)}.#{sized(3) { string(:alpha) }}".downcase
   end
 
   def password

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,7 +32,7 @@ class Rantly
   end
 
   class TooManyTries < RuntimeError
-    def initialize(limit,nfailed)
+    def initialize(limit, nfailed)
       @limit = limit
       @nfailed = nfailed
     end
@@ -41,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
@@ -80,7 +79,7 @@ class Rantly
       end
       nsuccess += 1
       limit -= 1
-      handler.call(val) if handler
+      yield(val) if handler
     end
   end
 
@@ -100,87 +99,89 @@ class Rantly
   end
 
   def guard(test)
-    unless test
-      raise GuardFailure.new
-    else
-      true
-    end
+    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_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(distribution=nil, params={})
+  def float(distribution = nil, params = {})
     case distribution
     when :normal
       params[:center] ||= 0
       params[:scale] ||= 1
-      raise "The distribution scale should be greater than zero" unless params[:scale] > 0
+      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].reduce(0, :+) - 3) * params[:scale] + params[:center]
+      ([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)
@@ -188,52 +189,50 @@ 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(n=self.size,&block)
-    n.times.map { self.instance_eval(&block) }
+  def array(n = size, &block)
+    n.times.map { instance_eval(&block) }
   end
 
-  def dict(n=self.size,&block)
+  def dict(n = size, &block)
     h = {}
     each(n) do
-      k,v = instance_eval(&block)
-      h[k] = v if guard(!h.has_key?(k))
+      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_with_object("") { |i, obj| obj << i }
+      ASCII = (0..127).to_a.each_with_object('') { |i, obj| obj << i }
 
       def of(regexp)
         ASCII.scan(regexp).to_a.map! { |char| char[0].ord }
@@ -254,41 +253,35 @@ class Rantly
     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
+    raise 'bad arg' unless chars
 
-    char_strings = chars.map { |c| c.chr }
+    char_strings = chars.map(&:chr)
     str = Array.new(size)
-    current_index = 0
-    while current_index < size
-      str[current_index] = char_strings.sample
-      current_index += 1
-    end
+    size.times { |i| str[i] = char_strings.sample }
     str.join
   end
 end

data/lib/rantly/minitest_extensions.rb

@@ -1,5 +1,6 @@
 require 'minitest'
 require 'rantly/property'
+require "minitest/unit" unless defined?(MiniTest)
 
 test_class = if defined?(MiniTest::Test)
                MiniTest::Test

data/lib/rantly/property.rb

@@ -3,14 +3,14 @@ require 'pp'
 require 'stringio'
 
 class Rantly::Property
-  attr_reader :failed_data, :shrunk_failed_data, :io
+  attr_reader :failed_data, :shrunk_failed_data
 
-  VERBOSITY = ENV.fetch('RANTLY_VERBOSE'){ 1 }.to_i
-  RANTLY_COUNT = ENV.fetch('RANTLY_COUNT'){ 100 }.to_i
+  VERBOSITY = ENV.fetch('RANTLY_VERBOSE', 1).to_i
+  RANTLY_COUNT = ENV.fetch('RANTLY_COUNT', 100).to_i
 
   def io
     @io ||= if VERBOSITY >= 1
-              STDOUT
+              $stdout
             else
               StringIO.new
             end
@@ -24,46 +24,43 @@ class Rantly::Property
     @property = property
   end
 
-  def check(n=RANTLY_COUNT,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
-        io.puts "" if i % 100 == 0
-        io.print "." if i % 10 == 0
+        yield(val) if assertion
+        io.puts '' if (i % 100).zero?
+        io.print '.' if (i % 10).zero?
         i += 1
       end
       io.puts
-      io.puts "success: #{i} tests"
+      io.puts "SUCCESS - #{i} successful tests"
     rescue Rantly::TooManyTries => e
       io.puts
-      io.puts "too many tries: #{e.tries}"
-      raise e
-    rescue Exception => boom
+      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} tests, on:"
+      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:"
+        io.puts "Minimal failed data (depth #{@depth}) is:"
         pretty_print @shrunk_failed_data
       end
-      raise $!, "failure: #{i} tests, on:\n#{test_data}\n\n#{boom}\n", $@
+      raise e.exception("#{i} successful tests, failed on:\n#{test_data}\n\n#{e}\n")
     end
   end
 
   # Explore the failures tree
-  def shrinkify(assertion, data, depth=0, iteration=0)
-    io.puts "Shrinking at depth #{depth}:"
-    pretty_print data
-
+  def shrinkify(assertion, data, depth = 0, iteration = 0)
     min_data = data
     max_depth = depth
     if data.shrinkable?
-      while iteration < 1024 do
+      while iteration < 1024
         # We assume that data.shrink is non-destructive
         shrunk_data = data.shrink
         begin
@@ -76,9 +73,9 @@ class Rantly::Property
             max_depth = branch_depth
           end
         end
-        break if !data.retry?
+        break unless data.retry?
       end
     end
-    return min_data, max_depth, iteration
+    [min_data, max_depth, iteration]
   end
 end

data/lib/rantly/rspec_extensions.rb

@@ -1,4 +1,4 @@
-require 'rspec'
+require 'rspec/core'
 require 'rantly/property'
 
 class RSpec::Core::ExampleGroup