rantly 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5d5909494bebecbd6f94ce3c8e9de705072d5811
-  data.tar.gz: e04f4f9530d3dce1361cbe01cf318995c1f67399
+SHA256:
+  metadata.gz: 79dd7dec8dc33c88121e8f18e937c066730f92d190e34657742245d5d2ad39ce
+  data.tar.gz: 0d0a1435d25e7ad2d1948d45040a6524b79425011289331484b35b0387d7d750
 SHA512:
-  metadata.gz: '00709b69bbccfe71a42295cf0551616281cd318c0704e5f53f48d90c93423271fc472f3ccca82ca2f77f45eb5f6cd7d5954254e727b24592e004fda69c1f6d0f'
-  data.tar.gz: 19491d969d644a1be5675582427ac75eee88bb0762cda4d38608d03bba9a0f12dc9c75c646e02130f7bb9db5774c47e939f4945080a1471ec283fb7aab5095c7
+  metadata.gz: 7f652b90718f7d9f32c1e88995d85371cd87af8d247b7def676a171b58f170cb08d0d29f54cb68259a7f4f42c64299d7c1b8f1741095c9dc174e4208904535b0
+  data.tar.gz: 54a9a7f6c94741379d58268fb56a0fb47e8787868e5f8610904a2c551d65041e6042470a3a3514acd0a585a2e75859b26f73605b0a55e5352f0a913a83b4742c

data/.travis.yml

@@ -9,11 +9,5 @@ rvm:
     - 2.2.6
     - 2.3.3
     - 2.4.0
-    - rbx-2.5.8
-    - rbx-3.70
     - jruby-1.7.26
     - jruby-9.1.7.0
-matrix:
-  allow_failures:
-    - rvm: rbx-2.5.8
-    - rvm: rbx-3.70

data/CHANGELOG.md

@@ -3,6 +3,20 @@ All notable changes to rantly will be documented in this file. The curated log b
 
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [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
+  - [Issue #29](https://github.com/rantly-rb/rantly/issues/29)
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez] and [Víctor Gallego][Víctor Gallego]
+### Bug fixes
+- `NoMethodError` - undefined method `retry?` - when a test using `dict` fails
+  - [Issue #39](https://github.com/rantly-rb/rantly/issues/39)
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+### Changes
+- Correct typo in _Too many tries_ message
+  - thanks [Ana María Martínez Gómez][Ana María Martínez Gómez]
+
+
 ## [1.1.0][1.1.0] - 2017-04-18
 ### Improved
 - Include failed example and number of example run in failure message.
@@ -44,3 +58,4 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 [Jamie English]:            https://github.com/english
 [Oleksii Fedorov]:          https://github.com/waterlink
 [Ana María Martínez Gómez]: https://github.com/Ana06
+[Víctor Gallego]:           https://github.com/vicgalle

data/{README.textile → README.md}

@@ -1,8 +1,7 @@
-!https://badge.fury.io/rb/rantly.svg!:https://badge.fury.io/rb/rantly
+[![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)
 
-!https://travis-ci.org/abargnesi/rantly.svg?branch=master!:https://travis-ci.org/abargnesi/rantly
-
-h1. Imperative Random Data Generator and Quickcheck
+# Imperative Random Data Generator and Quickcheck
 
 You can use Rantly to generate random test data, and use its Test::Unit extension for property-based testing.
 
@@ -10,13 +9,14 @@ Rantly is basically a recursive descent interpreter, each of its method returns
 
 Its implementation has no alien mathematics inside. Completely side-effect-free-free.
 
-h1. Install
 
-<pre><code>
+# Install
+
+```ruby
 $ gem install rantly
-</code></pre>
+```
 
-<pre><code>
+```ruby
 $ irb -rrantly
 > Rantly { [integer,float] } # same as Rantly.value { integer }
 => [20991307, 0.025756845811823]
@@ -24,32 +24,33 @@ $ irb -rrantly
 => [-376856492, 0.452245765751706]
 > Rantly(5) { integer } # same as Rantly.map(5) { integer }
 => [-1843396915550491870, -1683855015308353854, -2291347782549033959, -951461511269053584, 483265231542292652]
-</code></pre>
+```
+
 
-h1. Data Generation
+# Data Generation
 
-h2. Getting Random Data Values
+## Getting Random Data Values
 
-<pre><code>
+```ruby
 Rantly#map(n,limit=10,&block)
   call the generator n times, and collect values
 Rantly#each(n,limit=10,&block)
   call a random block n times
 Rantly#value(limit=10,&block)
   call a random block once, and get its value.
-</code></pre>
+```
 
 To collect an array of random data,
 
-<pre><code>
+```ruby
 # we want 5 random integers
 > Rantly(5) { integer }
 => [-380638946, -29645239, 344840868, 308052180, -154360970]
-</code></pre>
+```
 
 To iterate over random data,
 
-<pre><code>
+```ruby
 > Rantly.each(5) { puts integer }
 296971291
 504994512
@@ -57,38 +58,38 @@ To iterate over random data,
 113152364
 502842783
 => nil
-</code></pre>
+```
 
 To get one value of random data,
 
-<pre><code>
+```ruby
 > Rantly { integer }
 => 278101042
-</code></pre>
+```
 
-The optional argument @limit@ is used with generator guard. By default, if you want to generate n items, the generator tries at most n * 10 times.
+The optional argument `limit` is used with generator guard. By default, if you want to generate n items, the generator tries at most n * 10 times.
 
 This almost always succeeds,
 
-<pre><code>
+```ruby
 > Rantly(5) { i = integer; guard i > 0; i }
 => [511765059, 250554234, 305947804, 127809156, 285960387]
-</code></pre>
+```
 
 This always fails,
 
-<pre><code>
+```ruby
 > Rantly(10) { guard integer.is_a?(Float) }
 Rantly::TooManyTries: Exceed gen limit 100: 101 failed guards)
-</code></pre>
+```
 
-h2. Random Generating Methods
+## Random Generating Methods
 
-The API is similiar to QuickCheck, but not exactly the same. In particular @choose@ picks a random element from an array, and @range@ picks a integer from an interval.
+The API is similiar to QuickCheck, but not exactly the same. In particular `choose` picks a random element from an array, and `range` picks a integer from an interval.
 
-h3. Simple Randomness
+## Simple Randomness
 
-<pre><code>
+```ruby
 Rantly#integer(n=nil)
   random positive or negative integer. Fixnum only.
 Rantly#range(lo,hi)
@@ -101,105 +102,104 @@ Rantly#literal(value)
   No-op. returns value.
 Rantly#choose(*vals)
   Pick one value from among vals.
-</code></pre>
+```
 
-h3. Meta Randomness
+## Meta Randomness
 
 A rant generator is just a mini interpreter. It's often useful to go meta,
 
-<pre><code>
+```ruby
 Rantly#call(gen)
   If gen is a Symbol, just do a method call with send.
   If gen is an Array, the first element of the array is the method name, the rest are args.
   If gen is a Proc, instance_eval it with the generator.
-</code></pre>
+```
 
-<pre><code>
+```ruby
 > Rantly { call(:integer) }
 => -240998958
-</code></pre>
+```
 
-<pre><code>
+```ruby
 > Rantly { call([:range,0,10]) }
 => 2
-</code></pre>
+```
 
-<pre><code>
+```ruby
 > Rantly { call(Proc.new { [integer] })}
 => [522807620]
-</code></pre>
+```
 
-The @call@ method is useful to implement other abstractions (See next subsection).
+The `call` method is useful to implement other abstractions (See next subsection).
 
-<pre><code>
+```ruby
 Rantly#branch(*args)
   Pick a random arg among args, and Rantly#call it.
-</code></pre>
+```
 
 50-50 chance getting an integer or float,
 
-<pre><code>
+```ruby
 > Rantly { branch :integer, :float }
 => 0.0489446702931332
 > Rantly { branch :integer, :float }
 => 494934533
-</code></pre>
+```
 
 
-h3. Frequencies
+## Frequencies
 
-<pre><code>
+```ruby
 Rantly#freq(*pairs)
   Takes a list of 2-tuples, the first of which is the weight, and the second a Rantly#callable value, and returns a random value picked from the pairs. Follows the distribution pattern specified by the weights.
-</code></pre>
+```
 
 Twice as likely to get a float than integer. Never gets a ranged integer.
 
-<pre><code>
+```ruby
 > Rantly { freq [1,:integer], [2,:float], [0,:range,0,10] }
-</code></pre>
+```
 
-If the "pair" is not an array, but just a symbol, @freq@ assumes that the weight is 1.
+If the "pair" is not an array, but just a symbol, `freq` assumes that the weight is 1.
 
-<pre><code>
+```ruby
 # 50-50 between integer and float
 > Rantly { freq :integer, :float }
-</code></pre>
+```
 
-If a "pair" is an Array, but the first element is not an Integer, @freq@ assumes that it's a Rantly method-call with arguments, and the weight is one.
+If a "pair" is an Array, but the first element is not an Integer, `freq` assumes that it's a Rantly method-call with arguments, and the weight is one.
 
-<pre><code>
+```ruby
 # 50-50 chance generating integer limited by 10, or by 20.
 > Rantly { freq [:integer,10], [:integer 20] }
-</code></pre>
+```
 
 
+## Sized Structure
 
-h3. Sized Structure
+A Rantly generator keeps track of how large a datastructure it should generate with its `size` attribute.
 
-A Rantly generator keeps track of how large a datastructure it should generate with its @size@ attribute.
-
-<pre><code>
+```ruby
 Rantly#size
  returns the current size
 Rantly#sized(n,&block)
  sets the size for the duration of recursive call of block. Block is instance_eval with the generator.
-</code></pre>
+```
 
 Rantly provides two methods that depends on the size
 
-<pre><code>
+```ruby
 Rantly#array(size=default_size,&block)
   returns a sized array consisted of elements by Rantly#calling random branches.
 Rantly#string(char_class=:print)
   returns a sized random string, consisted of only chars from a char_class.
 Rantly#dict(size=default_size,&block)
   returns a sized random hash. The generator block should generate tuples of keys and values (arrays that have two elements, the first one is used as key, and the second as value).
-</code></pre>
+```
 
 The avaiable char classes for strings are:
 
-<pre><code>
+```ruby
 :alnum
 :alpha
 :blank
@@ -213,31 +213,31 @@ The avaiable char classes for strings are:
 :upper
 :xdigit
 :ascii
-</code></pre>
+```
 
-<pre><code>
+```ruby
 # sized 10 array of integers
 > Rantly { array(10) { integer }}
 => [417733046, -375385433, 0.967812380000118, 26478621, 0.888588160450082, 250944144, 305584916, -151858342, 0.308123867823313, 0.316824642414253]
-</code></pre>
+```
 
 If you set the size once, it applies to all subsequent recursive structures. Here's a sized 10 array of sized 10 strings,
 
-<pre><code>
+```ruby
 > Rantly { sized(10) { array {string}} }
 => ["1c}C/,9I#}", "hpA/UWPJ\\j", "H'~ERtI`|]", "%OUaW\\%uQZ", "Z2QdY=G~G!", "H<o|<FARGQ", "g>ojnxGDT3", "]a:L[B>bhb", "_Kl=&{tH^<", "ly]Yfb?`6c"]
-</code></pre>
+```
 
 Or a sized 10 array of sized 5 strings,
 
-<pre><code>
+```ruby
 > Rantly {array(10){sized(5) {string}}}
 => ["S\"jf ", "d\\F-$", "-_8pa", "IN0iF", "SxRV$", ".{kQ7", "6>;fo", "}.D8)", "P(tS'", "y0v/v"]
-</code></pre>
+```
 
 Generate a hash that has 5 elements,
 
-<pre><code>
+```ruby
 > Rantly { dict { [string,integer] }}
 {"bR\\qHn"=>247003509502595457,
  "-Mp '."=>653206579583741142,
@@ -245,57 +245,58 @@ Generate a hash that has 5 elements,
  "+SMn:r"=>-1159506450084197716,
  "^3gYfQ"=>-2154064981943219558,
  "= :/\\,"=>433790301059833691}
-</code></pre>
+```
 
-The @dict@ generator retries if a key is duplicated. If it fails to generate a unique key after too many tries, it gives up by raising an error:
+The `dict` generator retries if a key is duplicated. If it fails to generate a unique key after too many tries, it gives up by raising an error:
 
-<pre><code>
+```ruby
 > Rantly { dict { ["a",integer] }}
 Rantly::TooManyTries: Exceed gen limit 60: 60 failed guards)
-</code></pre>
+```
+
 
-h1. Property Testing
+# Property Testing
 
 Rantly extends Test::Unit and MiniTest::Test (5.0)/MiniTest::Unit::TestCase (< 5.0) for property testing. The extensions are in their own modules. So you need to require them explicitly:
 
-<pre><code>
+```ruby
 require 'rantly/testunit_extensions' # for 'test/unit'
 require 'rantly/minitest_extensions' # for 'minitest'
 require 'rantly/rspec_extensions'    # for RSpec
-</code></pre>
+```
 
 They define:
 
-<pre><code>
+```ruby
 Test::Unit::Assertions#property_of(&block)
   The block is used to generate random data with a generator. The method returns a Rantly::Property instance, that has the method 'check'.
-</code></pre>
+```
 
 Property assertions within Test::Unit could be done like this,
 
-<pre><code>
+```ruby
 # checks that integer only generates fixnum.
 property_of {
   integer
 }.check { |i|
   assert(i.is_a?(Integer), "integer property did not return Integer type")
 }
-</code></pre>
+```
 
 Property assertions within Minitest could be done like this,
 
-<pre><code>
+```ruby
 # checks that integer only generates fixnum.
 property_of {
   integer
 }.check { |i|
   assert_kind_of Integer, i, "integer property did not return Integer type"
 }
-</code></pre>
+```
 
 Property assertions within RSpec could be done like this,
 
-<pre><code>
+```ruby
 # checks that integer only generates fixnum.
 it "integer property only returns Integer type" do
    property_of {
@@ -304,61 +305,61 @@ it "integer property only returns Integer type" do
      expect(i).to be_a(Integer)
    }
 end
-</code></pre>
+```
 
 The check block takes the generated data as its argument. One idiom I find useful is to include a parameter of the random data for the check argument. For example, if I want to check that Rantly#array generates the right sized array, I could say,
 
-<pre><code>
+```ruby
 property_of {
   len = integer
   [len,array(len){integer}]
 }.check { |(len,arr)|
   assert_equal len, arr.length
 }
-</code></pre>
+```
 
 To control the number of property tests to generate, you have three options. In order of precedence:
 
-# Pass an integer argument to @check@
+1. Pass an integer argument to `check`
 
-<pre><code>
+```ruby
 property_of {
   integer
 }.check(9000) { |i|
   assert_kind_of Integer, i
 }
-</code></pre>
+```
 
-#_ Set the @RANTLY_COUNT@ environment variable
+2. Set the `RANTLY_COUNT` environment variable
 
-<pre><code>
+```ruby
 RANTLY_COUNT=9000 ruby my_property_test.rb
-</code></pre>
+```
 
-#_ If neither of the above are set, the default will be to run the @check@ block 100 times.
+3. If neither of the above are set, the default will be to run the `check` block 100 times.
 
 If you wish to have quiet output from Rantly, set environmental variable:
-<pre><code>
+```ruby
 RANTLY_VERBOSE=0 # silent
 RANTLY_VERBOSE=1 # verbose and default if env is not set
-</code></pre>
+```
 This will silence the puts, print, and pretty_print statements in property.rb.
 
-h1. Shrinking
+# Shrinking
 
-Shrinking reduces the value of common types to some terminal lower bound. These functions are added to the Ruby types <code>Integer</code>, <code>String</code>, <code>Array</code>, and <code>Hash</code>.
+Shrinking reduces the value of common types to some terminal lower bound. These functions are added to the Ruby types `Integer`, `String`, `Array`, and `Hash`.
 
-For example a <code>String</code> is shrinkable until it is empty (e.g. <code>""</code>),
+For example a `String` is shrinkable until it is empty (e.g. `""`),
 
-<pre><code>
+```ruby
 "foo".shrinkable?     # => true
 "foo".shrink          # => "fo"
 "fo".shrink           # => "f"
 "f".shrink            # => ""
 "".shrinkable?        # => false
-</code></pre>
+```
 
-Shrinking allows <code>Property#check</code> to find a reduced value that still fails the condition. The value is not truely minimal because:
+Shrinking allows `Property#check` to find a reduced value that still fails the condition. The value is not truely minimal because:
 
 * we do not perform a complete in-depth traversal of the failure tree
 * we limit the search to a maximum 1024 shrinking operations
@@ -367,35 +368,41 @@ but is usually reduced enough to start debugging.
 
 Enable shrinking with
 
-<pre><code>
+```ruby
 require 'rantly/shrinks'
-</code></pre>
+```
 
-Use <code>Tuple</code> class if you want an array whose elements are individually shrinked, but are not removed. Example:
+Use `Tuple` class if you want an array whose elements are individually shrinked, but are not removed. Example:
 
-<pre><code>
+```ruby
 property_of {
   len = range(0, 10)
   Tuple.new( array(len) { integer } )
 }.check {
   # .. property check here ..
 }
-</code></pre>
+```
 
-Use <code>Deflating</code> class if you want an array whose elements are individully shrinked whenever possible, and removed otherwise. Example:
+Use `Deflating` class if you want an array whose elements are individully shrinked whenever possible, and removed otherwise. Example:
 
-<pre><code>
+```ruby
 property_of {
   len = range(0, 10)
-  Deflated.new( array(len) { integer } )
+  Deflating.new( array(len) { integer } )
 }.check {
   # .. property check here ..
 }
-</code></pre>
+```
 
 Normal arrays or hashes are not shrinked.
 
 
-h1. License
+# Contributors
+
+Thanks to [all contributors](https://github.com/rantly-rb/rantly/graphs/contributors). :cupid: New contributors are welcome! :wink:
+
+
+# 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":https://github.com/abargnesi/rantly/LICENSE

data/VERSION.yml

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

data/lib/rantly/generator.rb

@@ -42,7 +42,7 @@ class Rantly
     end
 
     def to_s
-      "Exceed gen limit #{@limit}: #{@nfailed} failed guards)"
+      "Exceed gen limit #{@limit}: #{@nfailed} failed guards"
     end
   end
 
@@ -121,7 +121,7 @@ class Rantly
   end
 
   # wanna avoid going into Bignum when calling range with these.
-  INTEGER_MAX = (2**(0.size * 8 -2) -1) / 2
+  INTEGER_MAX = (2**(0.size * 8 - 2) - 1) / 2
   INTEGER_MIN = -(INTEGER_MAX)
   def integer(limit=nil)
     case limit
@@ -141,8 +141,18 @@ class Rantly
     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" unless params[:scale] > 0
+      # 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]
+    else
+      rand
+    end
   end
 
   def range(lo=nil,hi=nil)
@@ -230,19 +240,19 @@ class Rantly
       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 = {

data/lib/rantly/property.rb

@@ -81,12 +81,4 @@ class Rantly::Property
     end
     return min_data, max_depth, iteration
   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
-    end
-  end
 end

data/lib/rantly/shrinks.rb

@@ -191,4 +191,8 @@ class Hash
     self.any?{|_,v| v.respond_to?(:shrinkable?) && v.shrinkable? } ||
       !self.empty?
   end
+
+  def retry?
+    false
+  end
 end

data/rantly.gemspec

@@ -1,14 +1,15 @@
 Gem::Specification.new do |s|
   s.name             = "rantly"
   s.summary          = "Ruby Imperative Random Data Generator and Quickcheck"
-  s.homepage         = "https://github.com/abargnesi/rantly"
-  s.version          = "1.1.0"
+  s.homepage         = "https://github.com/rantly-rb/rantly"
+  s.version          = "1.2.0"
+  s.license          = "MIT"
   s.require_paths    = ["lib"]
-  s.authors          = ["Howard Yeh", "Anthony Bargnesi", "Eric Bischoff"]
-  s.email            = ["hayeah@gmail.com", "abargnesi@gmail.com", "ebischoff@nerim.net"]
+  s.authors          = ["Ana María Martínez Gómez", "Howard Yeh", "Anthony Bargnesi", "Eric Bischoff"]
+  s.email            = ["anamma06@gmail.com", "hayeah@gmail.com", "abargnesi@gmail.com", "ebischoff@nerim.net"]
   s.extra_rdoc_files = [
     "LICENSE",
-    "README.textile",
+    "README.md",
     "CHANGELOG.md"
   ]
   s.files            = [
@@ -16,7 +17,7 @@ Gem::Specification.new do |s|
     ".travis.yml",
     "Gemfile",
     "LICENSE",
-    "README.textile",
+    "README.md",
     "CHANGELOG.md",
     "Rakefile",
     "VERSION.yml",

data/test/rantly_test.rb

@@ -57,6 +57,17 @@ describe Rantly::Property do
     property_of { float }.check { |f| assert f.is_a?(Float)}
   end
 
+  it "generate Float with normal distribution" do
+    property_of{
+      center = integer(100)
+      normal_points =  Array.new(100){ float(:normal, { center: center }) }
+      [center, normal_points]
+    }.check{ |center, normal_points|
+      average_center = normal_points.reduce(0, :+) / 100
+      assert average_center.between?(center - 0.5, center + 0.5)
+    }
+  end
+
   it "generate Boolean" do
     property_of { boolean }.check { |t|
       assert t == true || t == false
@@ -136,14 +147,14 @@ describe Rantly::Property do
     }
     property_of {
       i0 = range(0,100)
-      i1,s = call Proc.new {
+      i1 = call Proc.new {
         range(i0+1,i0+100)
       }
       [i0,i1]
     }.check { |(i0,i1)|
       assert i0.is_a?(Fixnum) && i1.is_a?(Fixnum)
-      assert i0 != i1
       assert i1 > i0
+      assert i1 <= (i0 + 100)
     }
   end
 
@@ -255,14 +266,7 @@ describe Rantly::Property do
     property_of {
       sized(10) { array { freq(:integer,:string,:float)}  }
     }.check { |arr|
-      assert arr.all? { |o|
-        case o
-        when Fixnum, Float, String
-          true
-        else
-          false
-        end
-      }
+      assert arr.all? { |o| [Fixnum, Float, String].include? o.class }
     }
   end
 

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rantly
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
+- Ana María Martínez Gómez
 - Howard Yeh
 - Anthony Bargnesi
 - Eric Bischoff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-18 00:00:00.000000000 Z
+date: 2018-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -70,6 +71,7 @@ dependencies:
         version: '0'
 description: 
 email:
+- anamma06@gmail.com
 - hayeah@gmail.com
 - abargnesi@gmail.com
 - ebischoff@nerim.net
@@ -77,7 +79,7 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
-- README.textile
+- README.md
 - CHANGELOG.md
 files:
 - ".document"
@@ -85,7 +87,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - LICENSE
-- README.textile
+- README.md
 - Rakefile
 - VERSION.yml
 - lib/rantly.rb
@@ -104,8 +106,9 @@ files:
 - test/rantly_test.rb
 - test/shrinks_test.rb
 - test/test_helper.rb
-homepage: https://github.com/abargnesi/rantly
-licenses: []
+homepage: https://github.com/rantly-rb/rantly
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -123,7 +126,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Ruby Imperative Random Data Generator and Quickcheck