random_token 1.0.1 → 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 738c05b70d8a4fc3c236ba237e90f131625ac1fc
+  data.tar.gz: 13d44098afbd728d3cc8390547d42f2dfa04ff82
+SHA512:
+  metadata.gz: 846909049c446fa3eaad0af077a273b8a051d9ef4a51d706a656a4ee6a72beedef0102cecaa54ea1f2657f0f4b7d1839c9dc2b1502cfecbb11fb4acba701f372
+  data.tar.gz: d87701e82fcf89f3dca17c702c7dea13c08d1cedf8c83fba8e6035551f4c140fedf5b399bdae9f8e541e70dd1cad6580cbacff56306f341a583ed0b502bed1d0

data/HISTORY.md

@@ -0,0 +1,5 @@
+=== v1.0.2 / 2014-09-30
+
+* [Dependence] Use new unit test syntex for testing, require minitest ~> 5.0
+* [Change] Use "SecureRandom.random_number" instead of "rand"
+

data/README.md

@@ -2,9 +2,11 @@
 
 [![Gem Version](https://badge.fury.io/rb/random_token.png)][gem]
 [![Build Status](https://travis-ci.org/sibevin/random_token.png?branch=build)][travis]
+[![Coverage Status](https://coveralls.io/repos/sibevin/random_token/badge.png?branch=cover-check)][coveralls]
 
 [gem]: https://rubygems.org/gems/random_token
 [travis]: https://travis-ci.org/sibevin/random_token
+[coveralls]:https://coveralls.io/r/sibevin/random_token?branch=cover-check
 
 A simple way to generate a random token.
 

data/lib/random_token.rb

@@ -1,4 +1,5 @@
 require "random_token/random_token_error"
+require "securerandom"
 
 module RandomToken
 
@@ -104,7 +105,7 @@ module RandomToken
     #   Please see {RandomToken::RandomTokenError}
     def gen(arg, options = {})
       arg_dispatcher(arg, options) do |length, seeds|
-        (0...length).map{ seeds[rand(seeds.length)] }.join
+        (0...length).map{ seeds[SecureRandom.random_number(seeds.length)] }.join
       end
     end
 
@@ -284,7 +285,7 @@ module RandomToken
       if opt[:support_case]
         case_opt = opt[:case] || opt[:default_case]
         case case_opt
-          when :up, :u 
+          when :up, :u
             cased_seed = opt[:seed].map { |s| s.upcase }
           when :down, :d, :lower, :l
             cased_seed = opt[:seed].map { |s| s.downcase }
@@ -298,7 +299,7 @@ module RandomToken
       else
         raise RandomTokenError.new(:not_support_case, opt) if opt[:case] != nil
       end
-      if opt[:support_friendly] 
+      if opt[:support_friendly]
         if opt[:friendly] || (opt[:friendly] == nil && opt[:mask])
           masked_seed = opt[:seed].dup
           mask = opt[:mask] || MASK

data/lib/random_token/version.rb

@@ -1,3 +1,3 @@
 module RandomToken
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/random_token.gemspec

@@ -16,10 +16,10 @@ Use "gen" method to create a random token with a given length.
 
 Some options can help to modify the token format.
 
-  RandomToken.gen(20, :seed => :alphabet, :friendly => true, :case => :up)
+  RandomToken.gen(20, seed: :alphabet, friendly: true, case: :up)
   # "YTHJHTXKSSXTPLARALRH"
 
-Use string format to create a random in the particular format. 
+Use string format to create a random in the particular format.
 
   RandomToken.gen("Give me a token %8?")
   # "Give me a token 6HRQZp8O"
@@ -31,4 +31,5 @@ Please see "README" to get more details.
   spec.files         = `git ls-files`.split($/)
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
+  spec.add_development_dependency 'minitest', '~> 5.0'
 end

data/test/format/test_pattern.rb

@@ -1,51 +1,51 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestPattern < Test::Unit::TestCase
+class TestPattern < Minitest::Test
   def test_gen_should_create_a_random_with_alphabets
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}A===%#{length}a===Aa==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[A-Z]{#{length}}===[a-z]{#{length}}===Aa===$/, token)
   end
 
   def test_gen_should_create_a_random_with_numbers
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}n===n==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[0-9]{#{length}}===n===$/, token)
   end
 
   def test_gen_should_create_a_random_with_0_and_1
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}b===b==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[0-1]{#{length}}===b===$/, token)
   end
 
   def test_gen_should_create_a_random_with_octal_digits
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}o===o==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[0-8]{#{length}}===o===$/, token)
   end
 
   def test_gen_should_create_a_random_with_hexadecimal_digits
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}h===%#{length}H===hH==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[0-9a-f]{#{length}}===[0-9A-F]{#{length}}===hH===$/, token)
   end
 
   def test_gen_should_create_a_random_with_alphabets_and_numbers
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}x===%#{length}X===xX==="
     token = RandomToken.gen(pattern)
     assert_match(/^===[0-9a-z]{#{length}}===[0-9A-Z]{#{length}}===xX===$/, token)
   end
 
   def test_gen_should_create_a_random_with_given_format
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}?===?==="
     token = RandomToken.gen(pattern)
     assert_match(/^===.{#{length}}===\?===$/, token)
@@ -53,7 +53,7 @@ class TestPattern < Test::Unit::TestCase
 
   def test_gen_should_raise_an_exception_if_the_given_pattern_is_invalid
     pattern = "===%123==="
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(pattern) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(pattern) }
     assert(e.code == :invalid_strf_pattern)
   end
 end

data/test/format/test_percent.rb

@@ -1,9 +1,9 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestPercent < Test::Unit::TestCase
+class TestPercent < Minitest::Test
   def test_gen_should_create_a_random_with_percent_signs
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}%===%%==="
     token = RandomToken.gen(pattern)
     assert_match(/^===%{#{length}}===%===$/, token)

data/test/get/test_case.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestCase < Test::Unit::TestCase
+class TestCase < Minitest::Test
   def test_get_should_create_a_random_with_upper_case_alphabets_or_numbers
     length = 10000
     token = RandomToken.get(length, :case => :up)
@@ -20,13 +20,13 @@ class TestCase < Test::Unit::TestCase
 
   def test_get_should_not_support_case_feature_when_creating_binray_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :b, :case => :up) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :b, :case => :up) }
     assert(e.code == :not_support_case)
   end
 
   def test_get_should_not_support_case_feature_when_creating_octal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :o, :case => :up) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :o, :case => :up) }
     assert(e.code == :not_support_case)
   end
 

data/test/get/test_friendly.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestFriendly < Test::Unit::TestCase
+class TestFriendly < Minitest::Test
   def test_get_should_not_create_a_random_including_masked_alphabets_or_numbers
     length = 10000
     token = RandomToken.get(length, :friendly => true)
@@ -10,19 +10,19 @@ class TestFriendly < Test::Unit::TestCase
 
   def test_get_should_not_support_friendly_feature_when_creating_binary_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :b, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :b, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 
   def test_get_should_not_support_friendly_feature_when_creating_octal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :o, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :o, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 
   def test_get_should_not_support_friendly_feature_when_creating_hexadecimal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :h, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => :h, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 

data/test/get/test_hash_seed.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestHashSeed < Test::Unit::TestCase
+class TestHashSeed < Minitest::Test
   def test_get_should_create_a_random_with_the_given_seeds
     length = 10000
     token = RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 })
@@ -20,7 +20,7 @@ class TestHashSeed < Test::Unit::TestCase
 
   def test_get_should_not_support_case_feature_when_given_the_hash_seed
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { 
+    e = assert_raises(RandomToken::RandomTokenError) {
       RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :case => :up)
     }
     assert(e.code == :not_support_case)
@@ -28,7 +28,7 @@ class TestHashSeed < Test::Unit::TestCase
 
   def test_get_should_not_support_friendly_feature_when_given_the_hash_seed
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { 
+    e = assert_raises(RandomToken::RandomTokenError) {
       RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :friendly => true)
     }
     assert(e.code == :not_support_friendly)

data/test/get/test_length.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestLength < Test::Unit::TestCase
+class TestLength < Minitest::Test
   def test_get_should_create_a_given_length_random_string
     length = 8
     token = RandomToken.get(length)

data/test/get/test_mask.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestMask < Test::Unit::TestCase
+class TestMask < Minitest::Test
   def test_get_should_use_given_mask
     length = 10000
     mask = ['a','b','c','d','e','0','1','2','3','4']
@@ -12,7 +12,7 @@ class TestMask < Test::Unit::TestCase
   def test_get_should_raise_an_exception_if_mask_is_given_but_friendly_option_is_false
     length = 10000
     mask = ['a','b','c','d','e','0','1','2','3','4']
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :mask => mask,
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :mask => mask,
                                                                               :friendly => false) }
     assert(e.code == :false_friendly_with_given_mask)
   end
@@ -21,7 +21,7 @@ class TestMask < Test::Unit::TestCase
     length = 10000
     seed = ['a']
     mask = ['a']
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => seed,
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.get(length, :seed => seed,
                                                                               :mask => mask) }
     assert(e.code == :mask_remove_all_seeds)
   end

data/test/get/test_seed.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require 'minitest/autorun'
 require "random_token"
 
-class TestSeed < Test::Unit::TestCase
+class TestSeed < Minitest::Test
   def test_get_should_create_a_random_with_alphabets_only
     length = 10000
     token = RandomToken.get(length, :seed => :a)

data/test/length/test_case.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestCase < Test::Unit::TestCase
+class TestCase < Minitest::Test
   def test_gen_should_create_a_random_with_upper_case_alphabets_or_numbers
     length = 10000
     token = RandomToken.gen(length, :case => :up)
@@ -28,13 +28,13 @@ class TestCase < Test::Unit::TestCase
 
   def test_gen_should_not_support_case_feature_when_creating_binray_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :b, :case => :up) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :b, :case => :up) }
     assert(e.code == :not_support_case)
   end
 
   def test_gen_should_not_support_case_feature_when_creating_octal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :o, :case => :up) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :o, :case => :up) }
     assert(e.code == :not_support_case)
   end
 

data/test/length/test_friendly.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestFriendly < Test::Unit::TestCase
+class TestFriendly < Minitest::Test
   def test_gen_should_not_create_a_random_including_masked_alphabets_or_numbers
     length = 10000
     token = RandomToken.gen(length, :friendly => true)
@@ -12,19 +12,19 @@ class TestFriendly < Test::Unit::TestCase
 
   def test_gen_should_not_support_friendly_feature_when_creating_binary_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :b, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :b, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 
   def test_gen_should_not_support_friendly_feature_when_creating_octal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :o, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :o, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 
   def test_gen_should_not_support_friendly_feature_when_creating_hexadecimal_random
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :h, :friendly => true) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :h, :friendly => true) }
     assert(e.code == :not_support_friendly)
   end
 

data/test/length/test_hash_seed.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestHashSeed < Test::Unit::TestCase
+class TestHashSeed < Minitest::Test
   def test_gen_should_create_a_random_with_the_given_seeds
     length = 10000
     token = RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 })
@@ -20,7 +20,7 @@ class TestHashSeed < Test::Unit::TestCase
 
   def test_gen_should_not_support_case_feature_when_given_the_hash_seed
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { 
+    e = assert_raises(RandomToken::RandomTokenError) { 
       RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :case => :up)
     }
     assert(e.code == :not_support_case)
@@ -28,7 +28,7 @@ class TestHashSeed < Test::Unit::TestCase
 
   def test_gen_should_not_support_friendly_feature_when_given_the_hash_seed
     length = 10000
-    e = assert_raise(RandomToken::RandomTokenError) { 
+    e = assert_raises(RandomToken::RandomTokenError) { 
       RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :friendly => true)
     }
     assert(e.code == :not_support_friendly)

data/test/length/test_length.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestLength < Test::Unit::TestCase
+class TestLength < Minitest::Test
   def test_gen_should_create_a_given_length_random_string
     length = 8
     token = RandomToken.gen(length)

data/test/length/test_mask.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestMask < Test::Unit::TestCase
+class TestMask < Minitest::Test
   def test_gen_should_use_given_mask
     length = 10000
     mask = ['a','b','c','d','e','0','1','2','3','4']
@@ -14,7 +14,7 @@ class TestMask < Test::Unit::TestCase
   def test_gen_should_raise_an_exception_if_mask_is_given_but_friendly_option_is_false
     length = 10000
     mask = ['a','b','c','d','e','0','1','2','3','4']
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :mask => mask,
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :mask => mask,
                                                                               :friendly => false) }
     assert(e.code == :false_friendly_with_given_mask)
   end
@@ -23,7 +23,7 @@ class TestMask < Test::Unit::TestCase
     length = 10000
     seed = ['a']
     mask = ['a']
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => seed,
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => seed,
                                                                               :mask => mask) }
     assert(e.code == :mask_remove_all_seeds)
   end

data/test/length/test_seed.rb

@@ -1,7 +1,7 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestSeed < Test::Unit::TestCase
+class TestSeed < Minitest::Test
   def test_gen_should_create_a_random_with_alphabets_only
     length = 10000
     token = RandomToken.gen(length, :seed => :a)

data/test/strf/test_pattern.rb

@@ -1,51 +1,51 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestPattern < Test::Unit::TestCase
+class TestPattern < Minitest::Test
   def test_get_should_create_a_random_with_alphabets
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}A===%#{length}a===Aa==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[A-Z]{#{length}}===[a-z]{#{length}}===Aa===$/, token)
   end
 
   def test_get_should_create_a_random_with_numbers
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}n===n==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[0-9]{#{length}}===n===$/, token)
   end
 
   def test_get_should_create_a_random_with_0_and_1
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}b===b==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[0-1]{#{length}}===b===$/, token)
   end
 
   def test_get_should_create_a_random_with_octal_digits
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}o===o==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[0-8]{#{length}}===o===$/, token)
   end
 
   def test_get_should_create_a_random_with_hexadecimal_digits
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}h===%#{length}H===hH==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[0-9a-f]{#{length}}===[0-9A-F]{#{length}}===hH===$/, token)
   end
 
   def test_get_should_create_a_random_with_alphabets_and_numbers
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}x===%#{length}X===xX==="
     token = RandomToken.strf(pattern)
     assert_match(/^===[0-9a-z]{#{length}}===[0-9A-Z]{#{length}}===xX===$/, token)
   end
 
   def test_get_should_create_a_random_with_given_format
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}?===?==="
     token = RandomToken.strf(pattern)
     assert_match(/^===.{#{length}}===\?===$/, token)
@@ -53,7 +53,7 @@ class TestPattern < Test::Unit::TestCase
 
   def test_get_should_raise_an_exception_if_the_given_pattern_is_invalid
     pattern = "===%123==="
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.strf(pattern) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.strf(pattern) }
     assert(e.code == :invalid_strf_pattern)
   end
 end

data/test/strf/test_percent.rb

@@ -1,9 +1,9 @@
-require "test/unit"
+require "minitest/autorun"
 require "random_token"
 
-class TestPercent < Test::Unit::TestCase
+class TestPercent < Minitest::Test
   def test_get_should_create_a_random_with_percent_signs
-    length = 10000 
+    length = 10000
     pattern = "===%#{length}%===%%==="
     token = RandomToken.strf(pattern)
     assert_match(/^===%{#{length}}===%===$/, token)

data/test/test_all.rb

@@ -1,4 +1,4 @@
-require "test/unit"
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"

data/test/test_gen.rb

@@ -1,4 +1,4 @@
-require "test/unit"
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"
@@ -12,20 +12,20 @@ require "length/test_hash_seed"
 require "format/test_pattern"
 require "format/test_percent"
 
-class TestGen < Test::Unit::TestCase
+class TestGen < Minitest::Test
   def test_gen_should_raise_an_exception_if_the_given_arg_is_invalid
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(nil) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(nil) }
     assert(e.code == :invalid_gen_arg)
   end
 
   def test_gen_should_raise_an_exception_if_the_given_options_are_duplicated
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(8, :s => :a, :seed => :o) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(8, :s => :a, :seed => :o) }
     assert(e.code == :duplicated_option)
   end
 
   def test_gen_should_raise_an_exception_if_the_given_option_values_are_invalid
     invalid_value = 'invalid_value'
-    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(8, :c => invalid_value) }
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(8, :c => invalid_value) }
     assert(e.code == :invalid_option_value)
   end
 end

data/test/test_get.rb

@@ -1,4 +1,4 @@
-require "test/unit"
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"

data/test/test_strf.rb

@@ -1,4 +1,4 @@
-require "test/unit"
+require 'minitest/autorun'
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"

metadata

@@ -1,16 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: random_token
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.0.2
 platform: ruby
 authors:
 - Sibevin Wang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-03 00:00:00.000000000 Z
-dependencies: []
+date: 2014-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: A simple way to generate a random token.
 email:
 - sibevin@gmail.com
@@ -18,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- HISTORY.md
 - LICENSE.txt
 - README.md
 - lib/random_token.rb
@@ -48,32 +62,31 @@ files:
 homepage: https://github.com/sibevin/random_token
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.1
 signing_key: 
-specification_version: 3
-summary: ! 'Use "gen" method to create a random token with a given length.  RandomToken.gen(8)
+specification_version: 4
+summary: 'Use "gen" method to create a random token with a given length.  RandomToken.gen(8)
   # "iUEFxcG2"  Some options can help to modify the token format.  RandomToken.gen(20,
-  :seed => :alphabet, :friendly => true, :case => :up) # "YTHJHTXKSSXTPLARALRH"  Use
-  string format to create a random in the particular format.   RandomToken.gen("Give
-  me a token %8?") # "Give me a token 6HRQZp8O"  Please see "README" to get more details.'
+  seed: :alphabet, friendly: true, case: :up) # "YTHJHTXKSSXTPLARALRH"  Use string
+  format to create a random in the particular format.  RandomToken.gen("Give me a
+  token %8?") # "Give me a token 6HRQZp8O"  Please see "README" to get more details.'
 test_files:
 - test/format/test_pattern.rb
 - test/format/test_percent.rb