rantly 1.2.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79dd7dec8dc33c88121e8f18e937c066730f92d190e34657742245d5d2ad39ce
-  data.tar.gz: 0d0a1435d25e7ad2d1948d45040a6524b79425011289331484b35b0387d7d750
+  metadata.gz: 13f1bd6f943416c68aff13d50f505ff92485c1613c4c01b52d8cbc78eb027b66
+  data.tar.gz: af1de15faf3be9d3984c1343eb59b65081d0d8c12916c07434e0353ee37a4204
 SHA512:
-  metadata.gz: 7f652b90718f7d9f32c1e88995d85371cd87af8d247b7def676a171b58f170cb08d0d29f54cb68259a7f4f42c64299d7c1b8f1741095c9dc174e4208904535b0
-  data.tar.gz: 54a9a7f6c94741379d58268fb56a0fb47e8787868e5f8610904a2c551d65041e6042470a3a3514acd0a585a2e75859b26f73605b0a55e5352f0a913a83b4742c
+  metadata.gz: 2f24ffc2cb269a377fb0b5c0e40897ba417ef991d5e219c0a0423458b8b5e760102ba1f32c157190f982419da8f8e6a32e628e1012a0d070d36045609e0a7255
+  data.tar.gz: bb6c3265fbfcd2a0d339dbdf87d6f38afb9e71c5f4f58531c92ce99d784ad5e66405f0a26b6caf6aed9a7cc86bebe6b4194273c389073041b7890abb79f51c03

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,10 @@
 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.0.0'
   gem 'simplecov', '>= 0'
-  gem 'coveralls', '>= 0', :require => false
+
+  gem 'rubocop'
 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 2.4 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
+:major: 2
+:minor: 0
 :patch: 0

data/lib/rantly.rb

@@ -1,14 +1,14 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$LOAD_PATH.unshift(File.dirname(__FILE__)) unless
+  $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(__dir__)
 
 class Rantly
 end
 
 require 'rantly/generator'
 
-def Rantly(n=1,&block)
+def Rantly(n = 1, &block)
   if n > 1
-    Rantly.map(n,&block)
+    Rantly.map(n, &block)
   else
     Rantly.value(&block)
   end

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,5 +1,4 @@
 class Rantly
-
   class << self
     attr_writer :default_size
     def singleton
@@ -11,20 +10,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 +31,7 @@ class Rantly
   end
 
   class TooManyTries < RuntimeError
-    def initialize(limit,nfailed)
+    def initialize(limit, nfailed)
       @limit = limit
       @nfailed = nfailed
     end
@@ -41,38 +40,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 +78,7 @@ class Rantly
       end
       nsuccess += 1
       limit -= 1
-      handler.call(val) if handler
+      yield(val) if handler
     end
   end
 
@@ -100,87 +98,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 +188,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 +252,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