random_token 1.0.2 → 1.1.0

checksums.yaml

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

data/HISTORY.md

@@ -1,4 +1,8 @@
-=== v1.0.2 / 2014-09-30
+## v1.1.0 / 2014-10-01
+
+* [Feature] Support the byte-length mode
+
+## 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

@@ -191,6 +191,44 @@ With :hex seed, i.e, `s: :h`, the default case is changed to upper-case. You can
     RandomToken.gen(32, s: :h, c: :d)
     # "d331ce7dae87f3bb3dcb3975be9c430d"
 
+### Byte-Length
+
+Use `:b` (or `:byte`) option to enable byte-length mode. When byte-length mode is on, the length unit becomes "bytes". For example:
+
+    RandomToken.gen(32, s: :h)
+    # "066010B727E0619DF90635DBCFBBC9CA"
+    # length = 32
+
+    RandomToken.gen(32, s: :h, b: true)
+    # "7D8FC8241CB1E5EE32BFB61212275733485B73F2B25F61F3684411BC77ECE331"
+    # length = 32 * 2
+
+    RandomToken.gen(32, s: :o)
+    # "33660161373115273571641666235250"
+    # length = 32
+
+    RandomToken.gen(32, s: :o, b: true)
+    # "13247642533766132340045425736322366461201703655601042333031121363007327500236255017153153410577614717424243614637434623101413176"
+    # length = 32 * 4
+
+    RandomToken.gen(32, s: :b)
+    # "10110010010011001101011111001011"
+    # length = 32
+
+    RandomToken.gen(32, s: :b, b: true)
+    # "00110111000100101100001011010001100100101110011001101000101110110001110111110100010001000011110101011011001001101001001100110110000100111110100011100101101011010111100011001100000010101111000010111101000000110101001100110011011000000111101100110101101111100000000111110000000010010100010110101010001010111010101000100101010100110001101000111110110110111011011111100111000000010010110110011111101110101001101101101001101011111010100101100110100100100100010100110111100010010010100010010000111000010000000110100101"
+    # length = 32 * 16
+
+Only `:binary`, `:oct`, `:hex` seeds support the byte-length mode.
+
+    RandomToken.gen(32, b: true)
+    RandomToken::RandomTokenError: RandomToken::RandomTokenError
+
+The byte-length mode is not supported by format either.
+
+    RandomToken.gen("%32h", b: true)
+    RandomToken::RandomTokenError: RandomToken::RandomTokenError
+
 ## Use Cases
 
 ### Case 1
@@ -235,7 +273,7 @@ Uh, I don't think it is cool enough...
 
 ## Test
 
-Go to random_token gem folder and run
+Go to random_token gem folder and run (Note that you need minitest ~> 5.0 to run these tests)
 
     ruby ./test/test_all.rb
 

data/lib/random_token.rb

@@ -28,11 +28,13 @@ module RandomToken
       :seed => [NUMBERS, ALPHABETS],
       :support_friendly => true,
       :support_case => true,
-      :default_case => :mixed
+      :default_case => :mixed,
+      :support_byte => false,
+      :byte_mult => 1
     },
     :alphabet => {
       :abbr => [:letter, :a, :l],
-      :seed => [ALPHABETS],
+      :seed => [ALPHABETS]
     },
     :number => {
       :abbr => [:n, 1, 10],
@@ -43,19 +45,25 @@ module RandomToken
       :abbr => [:b, 2],
       :seed => [('0'..'1')],
       :support_case => false,
-      :support_friendly => false
+      :support_friendly => false,
+      :support_byte => true,
+      :byte_mult => 16
     },
     :oct => {
       :abbr => [:o, 8],
       :seed => [('0'..'7')],
       :support_case => false,
-      :support_friendly => false
+      :support_friendly => false,
+      :support_byte => true,
+      :byte_mult => 4
     },
     :hex => {
       :abbr => [:h, 16],
       :seed => [NUMBERS, ('A'..'F')],
       :support_friendly => false,
-      :default_case => :up
+      :default_case => :up,
+      :support_byte => true,
+      :byte_mult => 2
     }
   }
 
@@ -74,6 +82,10 @@ module RandomToken
     :friendly => {
       :abbr => :f,
       :value => [true, false]
+    },
+    :byte => {
+      :abbr => :b,
+      :value => [true, false]
     }
   }
 
@@ -186,7 +198,9 @@ module RandomToken
     # Generate/count token with a given length.
     def run_by_length(length, options)
       if block_given?
-        seeds = gen_seeds(options)[:seed]
+        final_opt = gen_seeds(options)
+        seeds = final_opt[:seed]
+        length = length * final_opt[:byte_mult] if final_opt[:byte]
         yield(length, seeds)
       else
         raise RandomTokenError.new(
@@ -200,6 +214,9 @@ module RandomToken
         raise RandomTokenError.new(
           "No block is given when calling run_by_pattern.")
       end
+      if options[:byte]
+        raise RandomTokenError.new(:format_not_support_byte, options)
+      end
       in_arg = false
       result = []
       length = ''
@@ -314,6 +331,9 @@ module RandomToken
         end
       end
       raise RandomTokenError.new(:mask_remove_all_seeds, opt) if opt[:seed] == []
+      if opt[:support_byte] == false && opt[:byte] != nil
+        raise RandomTokenError.new(:not_support_byte, opt)
+      end
       opt
     end
   end

data/lib/random_token/random_token_error.rb

@@ -41,6 +41,14 @@ module RandomToken
         :value => 9,
         :msg => "The given option value is invalid."
       },
+      :format_not_support_byte => {
+        :value => 10,
+        :msg => "The byte-length is not supported in the format mode."
+      },
+      :not_support_byte => {
+        :value => 11,
+        :msg => "The byte-length feature is not supported in this case, but the byte option is true."
+      },
     }
 
     attr_reader :code, :value, :msg, :info

data/lib/random_token/version.rb

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

data/test/length/test_byte.rb

@@ -0,0 +1,63 @@
+require "minitest/autorun"
+require "random_token"
+
+class TestByte < Minitest::Test
+  def test_gen_should_create_a_random_with_16xlength_with_binary_seed
+    length = 32
+    token = RandomToken.gen(length, :seed => :binary, :byte => true)
+    assert_match(/^[0-1]{#{length*16}}$/, token)
+    token = RandomToken.gen(length, :seed => :binary, :b => true)
+    assert_match(/^[0-1]{#{length*16}}$/, token)
+  end
+
+  def test_gen_should_create_a_random_with_4xlength_with_oct_seed
+    length = 32
+    token = RandomToken.gen(length, :seed => :oct, :byte => true)
+    assert_match(/^[0-7]{#{length*4}}$/, token)
+    token = RandomToken.gen(length, :seed => :oct, :b => true)
+    assert_match(/^[0-7]{#{length*4}}$/, token)
+  end
+
+  def test_gen_should_create_a_random_with_2xlength_with_hex_seed
+    length = 32
+    token = RandomToken.gen(length, :seed => :hex, :byte => true)
+    assert_match(/^[A-Z0-9]{#{length*2}}$/, token)
+    token = RandomToken.gen(length, :seed => :hex, :b => true)
+    assert_match(/^[A-Z0-9]{#{length*2}}$/, token)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_use_format
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen("%b", :byte => true) }
+    assert(e.code == :format_not_support_byte)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_creating_alphabet_number_random
+    length = 10000
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :byte => true) }
+    assert(e.code == :not_support_byte)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_creating_alphabet_random
+    length = 10000
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :a, :byte => true) }
+    assert(e.code == :not_support_byte)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_creating_number_random
+    length = 10000
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => :n, :byte => true) }
+    assert(e.code == :not_support_byte)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_creating_random_with_seed_array
+    length = 10000
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => ['a', 'b'], :byte => true) }
+    assert(e.code == :not_support_byte)
+  end
+
+  def test_gen_should_not_support_byte_feature_when_creating_random_with_seed_hash
+    length = 10000
+    e = assert_raises(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => {'a' => 1, 'b' => 2}, :byte => true) }
+    assert(e.code == :not_support_byte)
+  end
+end

data/test/length/test_seed.rb

@@ -5,89 +5,89 @@ class TestSeed < Minitest::Test
   def test_gen_should_create_a_random_with_alphabets_only
     length = 10000
     token = RandomToken.gen(length, :seed => :a)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :alphabet)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :l)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :letter)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :a)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :alphabet)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :l)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :letter)
-    assert_match(/^[A-Za-z]*$/, token)
+    assert_match(/^[A-Za-z]{#{length}}$/, token)
   end
 
   def test_gen_should_create_a_random_with_numbers_only
     length = 10000
     token = RandomToken.gen(length, :seed => :n)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :number)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => 1)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => 10)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :n)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :number)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => 1)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => 10)
-    assert_match(/^[0-9]*$/, token)
+    assert_match(/^[0-9]{#{length}}$/, token)
   end
 
   def test_gen_should_create_a_random_with_0_and_1_only
     length = 10000
     token = RandomToken.gen(length, :seed => :b)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :binary)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => 2)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :b)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :binary)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => 2)
-    assert_match(/^[01]*$/, token)
+    assert_match(/^[01]{#{length}}$/, token)
   end
 
   def test_gen_should_create_a_random_with_octal_digits
     length = 10000
     token = RandomToken.gen(length, :seed => :o)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :oct)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => 8)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :o)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :oct)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => 8)
-    assert_match(/^[0-7]*$/, token)
+    assert_match(/^[0-7]{#{length}}$/, token)
   end
 
   def test_gen_should_create_a_random_with_hexadecimal_digits
     length = 10000
     token = RandomToken.gen(length, :seed => :h)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => :hex)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
     token = RandomToken.gen(length, :seed => 16)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :h)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => :hex)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
     token = RandomToken.gen(length, :s => 16)
-    assert_match(/^[0-9A-F]*$/, token)
+    assert_match(/^[0-9A-F]{#{length}}$/, token)
   end
 
   def test_gen_should_create_a_random_with_given_seeds
@@ -98,9 +98,9 @@ class TestSeed < Minitest::Test
              '.', '>', '/', '?', '`', '~']
     token = RandomToken.gen(length, :seed => seeds)
     targets = "[#{Regexp.escape(seeds.join)}]"
-    assert_match(/^#{targets}*$/, token)
+    assert_match(/^#{targets}{#{length}}$/, token)
     token = RandomToken.gen(length, :s => seeds)
     targets = "[#{Regexp.escape(seeds.join)}]"
-    assert_match(/^#{targets}*$/, token)
+    assert_match(/^#{targets}{#{length}}$/, token)
   end
 end

data/test/test_gen.rb

@@ -9,6 +9,7 @@ require "length/test_friendly"
 require "length/test_seed"
 require "length/test_mask"
 require "length/test_hash_seed"
+require "length/test_byte"
 require "format/test_pattern"
 require "format/test_percent"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: random_token
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Sibevin Wang
@@ -46,6 +46,7 @@ files:
 - test/get/test_length.rb
 - test/get/test_mask.rb
 - test/get/test_seed.rb
+- test/length/test_byte.rb
 - test/length/test_case.rb
 - test/length/test_friendly.rb
 - test/length/test_hash_seed.rb
@@ -96,6 +97,7 @@ test_files:
 - test/get/test_length.rb
 - test/get/test_mask.rb
 - test/get/test_seed.rb
+- test/length/test_byte.rb
 - test/length/test_case.rb
 - test/length/test_friendly.rb
 - test/length/test_hash_seed.rb