random_token 1.0.0 → 1.0.1

data/README.md

@@ -1,5 +1,11 @@
 # Random Token
 
+[![Gem Version](https://badge.fury.io/rb/random_token.png)][gem]
+[![Build Status](https://travis-ci.org/sibevin/random_token.png?branch=build)][travis]
+
+[gem]: https://rubygems.org/gems/random_token
+[travis]: https://travis-ci.org/sibevin/random_token
+
 A simple way to generate a random token.
 
     jjukoguwegcvclkuhljvsblrpfnd
@@ -17,163 +23,179 @@ A simple way to generate a random token.
 
 ### Basic
 
-Use "gen" method to create a random token with a given length.
+Use "gen" method with a format string to create a random token.
+
+    RandomToken.gen("%8?")
+    # "6HRQZp8O"
+
+    RandomToken.gen("%4H-%4H-%4H-%4H")
+    # "FD77-2792-91A9-6CE3"
+
+Or just give the token length.
 
     RandomToken.gen(8)
     # "iUEFxcG2"
 
 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"
+
+Or just simplify as:
+
+    RandomToken.gen(20, s: :a, f: true, c: :u)
     # "YTHJHTXKSSXTPLARALRH"
 
-Use string format to create a random in the particular format. Please read "Format" below to get more details.
+### Format
+
+You can embed random tokens in your own string using a format string. Here are some examples:
+
+    RandomToken.gen("%2A-%4n")
+    # "VS-6921"
+
+    RandomToken.genf("Your redeem code: %16?")
+    # "Your redeem code: 4xgRH2JaLxtR3dWK"
+
+    RandomToken.gen("Lucky Number = %n")
+    # "Lucky Number = 8"
+
+The directive consists of a percent(%), length, and type.
+
+    %[length][type]
+
+where
+
+*   length
+
+> The length of random token you want to create. The default value is 1 if no length is given.
+
+*   type
+
+> A - upper-case alphabets  
+> a - down-case alphabets  
+> n - numbers  
+> b - binaries  
+> o - octal digits  
+> H - upper-case hexadecimal digits  
+> h - down-case hexadecimal digits  
+> X - upper-case alphabets and numbers  
+> x - down-case alphabets and numbers  
+> ? - mixed-case alphabets and numbers  
+> % - show the % sign  
+
+`:seed`, `:friendly`, `:case` options are supported in the format string, and they would override the type behavior.
+
+    RandomToken.gen("%32X", seed: :a, friendly: true, case: :d)
+    # "ddbpeqhtmaenxsaksxrmeaawnwpkfess"
+
+### Length
+
+You can just give a token length. For example:
+
+    RandomToken.gen(8)
+    # "iUEFxcG2"
+
+The random token are created with mixed-case alphbets and numbers by default, same as the format string, you can use `:seed`, `:friendly`, `:case` options to modify the your token.
 
-    RandomToken.gen("Give me a token %8?")
-    # "Give me a token 6HRQZp8O"
+## Options
 
 ### Seed
 
-Use `:seed` option to customize the random characters.
+Use `:s` (or `:seed`) option to customize the random characters. Here are available options:
 
 Use `:a` (or `:alphabet`, `:l`, `:letter`) to create a token with alphabets.
 
-    RandomToken.gen(32, :seed => :a)
+    RandomToken.gen(32, s: :a)
     # "DTVbCnRldQnLAoERHAzjLOTJBTWoBGQb"
 
 Use `:n` (or `:number`, `10`, `1`) to create a token with numbers.
 
-    RandomToken.gen(32, :seed => :n)
+    RandomToken.gen(32, s: :n)
     # "41107838709625922353782552721916"
 
 Use `:b` (or `:binary`, `2`) to create a binary token.
 
-    RandomToken.gen(32, :seed => :b)
+    RandomToken.gen(32, s: :b)
     # "11101001110110110000101101010101"
 
 Use `:o` (or `:oct`, 8) to create a octal token.
 
-    RandomToken.gen(32, :seed => :o)
+    RandomToken.gen(32, s: :o)
     # "57531726664723324643140173424423"
 
 Use `:h` (or `:hex`, 16) to create a hexadecimal token.
 
-    RandomToken.gen(32, :seed => :h)
+    RandomToken.gen(32, s: :h)
     # "B7E1FD250D250008314496AE48EDE310"
 
 Use an `array` to customize random seeds.
 
-    RandomToken.gen(32, :seed => ['a', 'b', 'c'])
+    RandomToken.gen(32, s: ['a', 'b', 'c'])
     # "cbbcbcabbbacbaaababcbcabcacbcacb"
 
 Use a `hash` to customize random seeds and their distribution. For example, the following hash would create a token with "a" and "b" where p("a") = 1/3 and p("b") = 2/3.
 
-    RandomToken.gen(32, :seed => { 'a' => 1, 'b' => 2 })
+    RandomToken.gen(32, s: { 'a' => 1, 'b' => 2 })
     # "bbabbaaaabaabbbabbbbbbbbbaababbb"
 
-### Friendly
+### Friendly & Mask
 
-Use `:friendly` option to remove the ambiguous characters, the default mask includes *1, I, l, i, 0, O, o, Q, D, C, c, G, 9, 6, U, u, V, v, E, F, M, N, 8, B*.
+Use `:f` (or `:friendly`) option to remove the ambiguous characters, the default mask includes *1, I, l, i, 0, O, o, Q, D, C, c, G, 9, 6, U, u, V, v, E, F, M, N, 8, B*.
 
-    RandomToken.gen(32, :friendly => true)
+    RandomToken.gen(32, f: true)
     # "fjx5WTb4wbPmbwb7b4szzY4szfrqtJLj"
 
-The default `:friendly` option is false. There is a convenient method "genf" using `:friendly => true` by default.
+The default `:friendly` option is false. There is a convenient method "genf" using `friendly: true` by default.
 
     RandomToken.genf(32)
     # "kPafJh5gHAPJjYsssjW7yhthPr4Zg4t3"
 
 Friendly is not supported with some `:seed` options(`:b`, `:o`, `:h` and customized hash seeds).
 
-    RandomToken.genf(32, :seed => :b)
+    RandomToken.genf(32, s: :b)
     # RandomToken::RandomTokenError: RandomToken::RandomTokenError
 
-Use `:mask` to customize your own friendly mask. Note that `:friendly` is true by default if `:mask` is given.
+Use `:m` (or `:mask`) to customize your own friendly mask. Note that `:friendly` is true by default if `:mask` is given.
 
-    RandomToken.gen(32, :mask => ['a', 'A', 'b', 'c'])
+    RandomToken.gen(32, m: ['a', 'A', 'b', 'c'])
     # "QlHhMpfrGnOykMS8tpfYrW0EnqvRsItw"
 
 ### Case
 
-Use `:case` option to modify the token case.
+Use `:c` (or `:case`) option to modify the token case. Here are available options:
 
 Use `:u` (or `:up`) to create an upper-case token.
 
-    RandomToken.gen(32, :case => :u)
+    RandomToken.gen(32, c: :u)
     # "YKNOAMC5FQZTMRS9U3SI4U9QWEMU7TLL"
 
 Use `:d` (or `:down`) to create a down-case token.
 
-    RandomToken.gen(32, :case => :d)
+    RandomToken.gen(32, c: :d)
     # "8fvs6dfxko4buxcho23vz5jpxw9arj7t"
 
 Use `:m` (or `:mixed`) to create a mixed-case token. It is the default option.
 
-    RandomToken.gen(32, :case => :m)
+    RandomToken.gen(32, c: :m)
     # "BjWRJjU2iKF2O1cKrWpnF1EzZHuoUCM5"
 
 Case is not supported with some `:seed` options(`:n`, `:b`, `:o` and customized hash seeds).
 
-    RandomToken.gen(32, :seed => :n, :case => :u)
+    RandomToken.gen(32, s: :n, c: :u)
     # RandomToken::RandomTokenError: RandomToken::RandomTokenError
 
-With :hex seed, i.e, `:seed => :h`, the default case is changed to upper-case. You can override it by giving the `:case` option.
+With :hex seed, i.e, `s: :h`, the default case is changed to upper-case. You can override it by giving the `:case` option.
 
-    RandomToken.gen(32, :seed => :h, :case => :d)
+    RandomToken.gen(32, s: :h, c: :d)
     # "d331ce7dae87f3bb3dcb3975be9c430d"
 
-### Format
-
-You can embed random tokens in your own string using the format feature. Here are some examples:
-
-    RandomToken.gen("%4H-%4H-%4H-%4H")
-    # "FD77-2792-91A9-6CE3"
-
-    RandomToken.gen("%2A-%4n")
-    # "VS-6921" 
-
-    RandomToken.genf("Your redeem code: %16?")
-    # "Your redeem code: 4xgRH2JaLxtR3dWK"
-
-    RandomToken.gen("Lucky Number = %n")
-    # "Lucky Number = 8"
-
-The directive consists of a percent(%), length, and type.
-
-    %[length][type]
-
-where
-
-*   length
-
-> The length of random token you want to create. The default value is 1 if no length is given.
-
-*   type
-
-> A - upper-case alphabets  
-> a - down-case alphabets  
-> n - numbers  
-> b - binaries  
-> o - octal digits  
-> H - upper-case hexadecimal digits  
-> h - down-case hexadecimal digits  
-> X - upper-case alphabets and numbers  
-> x - down-case alphabets and numbers  
-> ? - mixed-case alphabets and numbers  
-> % - show the % sign  
-
-Note that `:seed`, `:friendly`, `:case` options are also supported in the format string, and they would override the type behavior.
-
-    RandomToken.gen("%32X", :seed => :a, :friendly => true, :case => :d)
-    # "ddbpeqhtmaenxsaksxrmeaawnwpkfess"
-
 ## Use Cases
 
 ### Case 1
 
 How to create a RPG random desert map?
 
-    1.upto(10).each { puts RandomToken.gen(28, :seed => { '.' => 1000, 'o' => 20, 'O' => 5, '_' => 1 }) }
+    1.upto(10).each { puts RandomToken.gen(28, s: { '.' => 1000, 'o' => 20, 'O' => 5, '_' => 1 }) }
 
     ............................
     .......................O.o..

data/lib/random_token.rb

@@ -58,7 +58,25 @@ module RandomToken
     }
   }
 
-  # The directives used in the {RandomToken.strf} method.
+  # The supported options
+  SUPPORTED_OPTS = {
+    :seed => {
+      :abbr => :s
+    },
+    :case => {
+      :abbr => :c,
+      :value => [:up, :u, :down, :d, :mixed, :m]
+    },
+    :mask => {
+      :abbr => :m
+    },
+    :friendly => {
+      :abbr => :f,
+      :value => [true, false]
+    }
+  }
+
+  # The directives used in the format string
   STRF_ARG_MAP = {
     'A' => { :seed => :alphabet, :case => :up },
     'a' => { :seed => :alphabet, :case => :down },
@@ -73,7 +91,7 @@ module RandomToken
   }
 
   class << self
-    # The major method to generate a random token. It would call {RandomToken.get} or {RandomToken.strf} according to the given arg.
+    # The major method to generate a random token.
     # @param arg [Fixnum, String]
     #   To give a token length or the string format for generating token.
     # @param options [Hash]
@@ -84,15 +102,9 @@ module RandomToken
     #   The generated token.
     # @raise [RandomTokenError]
     #   Please see {RandomToken::RandomTokenError}
-    # @see RandomToken.get
-    # @see RandomToken.strf
     def gen(arg, options = {})
-      if arg.class.name == 'Fixnum'
-        get(arg, options)
-      elsif arg.class.name == 'String'
-        strf(arg, options)
-      else
-        raise RandomTokenError.new(:invalid_gen_arg, arg)
+      arg_dispatcher(arg, options) do |length, seeds|
+        (0...length).map{ seeds[rand(seeds.length)] }.join
       end
     end
 
@@ -105,26 +117,90 @@ module RandomToken
       gen(arg, { :friendly => true }.merge(options))
     end
 
-    # To generate a random token with a given length.
-    # @param length [Fixnum]
-    #   The token length.
+    # TODO: Add count feature
+=begin
+    # Count the number of token combination with given arg and options.
+    # @param arg (see RandomToken.gen)
+    # @param options (see RandomToken.gen)
+    # @return [Fixnum] the number of combination
+    # @raise (see RandomToken.gen)
+    def count(arg, options = {})
+      arg_dispatcher(arg, options, true) do |length, seeds|
+        seeds.length ** length
+      end
+    end
+=end
+
+    # An old method for downward compatibility and it should be discarded.
+    # Use "gen" instead.
+    # @param arg (see RandomToken.gen)
     # @param options (see RandomToken.gen)
     # @return (see RandomToken.gen)
     # @raise (see RandomToken.gen)
-    def get(length, options = {})
-      seeds = gen_seeds(options)[:seed]
-      token = (0...length).map{ seeds[rand(seeds.length)] }.join
+    def get(arg, options = {})
+      gen(arg, options)
     end
 
-    # To generate a random token with a string format. Please see {file:README.rdoc} to get more detail usage and examples
-    # @param pattern [String]
-    #   The string format pattern.
+    # An old method for downward compatibility and it should be discarded.
+    # Use "gen" instead.
+    # @param arg (see RandomToken.gen)
     # @param options (see RandomToken.gen)
     # @return (see RandomToken.gen)
     # @raise (see RandomToken.gen)
-    def strf(pattern, options = {})
+    def strf(arg, options = {})
+      gen(arg, options)
+    end
+
+    private
+
+    # Decide how to generate/count token according to the arg type.
+    def arg_dispatcher(arg, options, count = false)
+      options = check_opt(options)
+      unless block_given?
+        raise RandomTokenError.new(
+          "No block is given when calling arg_dispatcher.")
+      end
+      if arg.is_a?(Fixnum)
+        run_by_length(arg, options) do |length, seeds|
+          yield(length, seeds)
+        end
+      elsif arg.is_a?(String)
+        result = run_by_pattern(arg, options) do |length, seeds|
+          yield(length, seeds)
+        end
+        return result.join
+        # TODO: Add count feature
+=begin
+        if count
+          return result.delete_if { |x| x.is_a?(String) }.inject(0, :*)
+        else
+          return result.join
+        end
+=end
+      else
+        raise RandomTokenError.new(:invalid_gen_arg, arg)
+      end
+    end
+
+    # Generate/count token with a given length.
+    def run_by_length(length, options)
+      if block_given?
+        seeds = gen_seeds(options)[:seed]
+        yield(length, seeds)
+      else
+        raise RandomTokenError.new(
+          "No block is given when calling run_by_length.")
+      end
+    end
+
+    # Generate/count token with a format string.
+    def run_by_pattern(pattern, options = {})
+      unless block_given?
+        raise RandomTokenError.new(
+          "No block is given when calling run_by_pattern.")
+      end
       in_arg = false
-      result = ''
+      result = []
       length = ''
       pattern.split(//).each do |x|
         if x == '%'
@@ -143,8 +219,8 @@ module RandomToken
           end
         elsif STRF_ARG_MAP.keys.include?(x)
           if in_arg
-            result << self.get((length == "") ? 1 : length.to_i,
-                               STRF_ARG_MAP[x].merge(options))
+            seeds = gen_seeds(STRF_ARG_MAP[x].merge(options))[:seed]
+            result << yield((length == "") ? 1 : length.to_i, seeds)
             length = ''
             in_arg = false
           else
@@ -161,9 +237,21 @@ module RandomToken
       result
     end
 
-    private
+    # Check options
+    def check_opt(opts)
+      SUPPORTED_OPTS.each do |key, value|
+        if opts[key] && opts.keys.include?(value[:abbr])
+          raise RandomTokenError.new(:duplicated_option, opts)
+        end
+        opts.merge!(key => opts[value[:abbr]]) if opts[value[:abbr]]
+        if value[:value] && opts[key] && !value[:value].include?(opts[key])
+          raise RandomTokenError.new(:invalid_option_value, opts)
+        end
+      end
+      opts
+    end
 
-    # To generate seeds according to the :seed options
+    # Generate seeds according to the :seed options
     def gen_seeds(opt)
       opt_seed = opt[:seed]
       default_opt = SEED_TYPES[:default]
@@ -181,15 +269,17 @@ module RandomToken
         return seed_modifier(default_opt.merge(:case => :keep).merge(opt))
       elsif opt_seed.is_a?(Hash)
         seeds = opt_seed.to_a.map {|s| (s.first * s.last).split(//)}.flatten
-        return seed_modifier(default_opt.merge(opt).merge(:seed => seeds,
-                                                          :support_case => false,
-                                                          :support_friendly => false ))
+        return seed_modifier(default_opt.
+                             merge(opt).
+                             merge(:seed => seeds,
+                                   :support_case => false,
+                                   :support_friendly => false ))
       else
         raise RandomTokenError.new(:unknown_seed, opt_seed)
       end
     end
 
-    # To modify seeds according to the :case, :friendly and :mask options
+    # Modify seeds according to the :case, :friendly and :mask options
     def seed_modifier(opt)
       if opt[:support_case]
         case_opt = opt[:case] || opt[:default_case]

data/lib/random_token/random_token_error.rb

@@ -32,7 +32,15 @@ module RandomToken
       :mask_remove_all_seeds => {
         :value => 7,
         :msg => "The friendly mask removes all seeds."
-      }
+      },
+      :duplicated_option => {
+        :value => 8,
+        :msg => "The same options are given."
+      },
+      :invalid_option_value => {
+        :value => 9,
+        :msg => "The given option value is invalid."
+      },
     }
 
     attr_reader :code, :value, :msg, :info

data/lib/random_token/version.rb

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

data/test/format/test_pattern.rb

@@ -0,0 +1,59 @@
+require "test/unit"
+require "random_token"
+
+class TestPattern < Test::Unit::TestCase
+  def test_gen_should_create_a_random_with_alphabets
+    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 
+    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 
+    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 
+    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 
+    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 
+    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 
+    pattern = "===%#{length}?===?==="
+    token = RandomToken.gen(pattern)
+    assert_match(/^===.{#{length}}===\?===$/, token)
+  end
+
+  def test_gen_should_raise_an_exception_if_the_given_pattern_is_invalid
+    pattern = "===%123==="
+    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(pattern) }
+    assert(e.code == :invalid_strf_pattern)
+  end
+end

data/test/format/test_percent.rb

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

data/test/get/test_case.rb

@@ -40,6 +40,7 @@ class TestCase < Test::Unit::TestCase
     length = 10000
     seeds = ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L', 'm', 'N']
     token = RandomToken.get(length, :seed => seeds)
-    assert_match(/^#{"[#{Regexp.escape(seeds.join)}]"}*$/, token)
+    targets = "[#{Regexp.escape(seeds.join)}]"
+    assert_match(/^#{targets}*$/, token)
   end
 end

data/test/get/test_seed.rb

@@ -63,6 +63,7 @@ class TestSeed < Test::Unit::TestCase
              '[', ']', '\\', '|', ';', ':', '\'', '"', ',', '<',
              '.', '>', '/', '?', '`', '~']
     token = RandomToken.get(length, :seed => seeds)
-    assert_match(/^#{"[#{Regexp.escape(seeds.join)}]"}*$/, token)
+    targets = "[#{Regexp.escape(seeds.join)}]"
+    assert_match(/^#{targets}*$/, token)
   end
 end

data/test/length/test_case.rb

@@ -0,0 +1,54 @@
+require "test/unit"
+require "random_token"
+
+class TestCase < Test::Unit::TestCase
+  def test_gen_should_create_a_random_with_upper_case_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.gen(length, :case => :up)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :case => :u)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :c => :up)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :c => :u)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+  end
+
+  def test_gen_should_create_a_random_with_lower_case_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.gen(length, :case => :down)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :case => :d)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :c => :down)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+    token = RandomToken.gen(length, :c => :d)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+  end
+
+  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) }
+    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) }
+    assert(e.code == :not_support_case)
+  end
+
+  def test_gen_should_use_upper_case_by_default_when_creating_hexdecimal_random
+    length = 10000
+    token = RandomToken.gen(length, :seed => :h)
+    assert_match(/^[0-9A-F]*$/, token)
+  end
+
+  def test_gen_should_keep_case_by_default_when_creating_random_with_given_seeds
+    length = 10000
+    seeds = ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L', 'm', 'N']
+    token = RandomToken.gen(length, :seed => seeds)
+    targets = "[#{Regexp.escape(seeds.join)}]"
+    assert_match(/^#{targets}*$/, token)
+  end
+end

data/test/length/test_friendly.rb

@@ -0,0 +1,37 @@
+require "test/unit"
+require "random_token"
+
+class TestFriendly < Test::Unit::TestCase
+  def test_gen_should_not_create_a_random_including_masked_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.gen(length, :friendly => true)
+    assert((RandomToken::MASK - token.split(//).uniq) == RandomToken::MASK)
+    token = RandomToken.gen(length, :f => true)
+    assert((RandomToken::MASK - token.split(//).uniq) == RandomToken::MASK)
+  end
+
+  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) }
+    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) }
+    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) }
+    assert(e.code == :not_support_friendly)
+  end
+
+  def test_gen_should_support_friendly_feature_when_creating_random_with_given_seeds
+    length = 10000
+    seeds = ['a','b','c','d','e','0','1','2','3','4']
+    token = RandomToken.gen(length, :seed => seeds, :friendly => true)
+    assert((token.split(//).uniq - RandomToken::MASK) == token.split(//).uniq)
+  end
+end

data/test/length/test_hash_seed.rb

@@ -0,0 +1,36 @@
+require "test/unit"
+require "random_token"
+
+class TestHashSeed < Test::Unit::TestCase
+  def test_gen_should_create_a_random_with_the_given_seeds
+    length = 10000
+    token = RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 })
+    assert_match(/^[a-c]{#{length}}$/, token)
+  end
+
+  def test_gen_should_create_a_random_with_the_given_distribution_of_seeds
+    length = 1000000
+    token = RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 })
+    a_count = token.count('a')
+    b_count = token.count('b')
+    c_count = token.count('c')
+    assert_in_delta(b_count.to_f/(2*a_count), 1, 0.01)
+    assert_in_delta(c_count.to_f/(3*a_count), 1, 0.01)
+  end
+
+  def test_gen_should_not_support_case_feature_when_given_the_hash_seed
+    length = 10000
+    e = assert_raise(RandomToken::RandomTokenError) { 
+      RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :case => :up)
+    }
+    assert(e.code == :not_support_case)
+  end
+
+  def test_gen_should_not_support_friendly_feature_when_given_the_hash_seed
+    length = 10000
+    e = assert_raise(RandomToken::RandomTokenError) { 
+      RandomToken.gen(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :friendly => true)
+    }
+    assert(e.code == :not_support_friendly)
+  end
+end

data/test/length/test_length.rb

@@ -0,0 +1,10 @@
+require "test/unit"
+require "random_token"
+
+class TestLength < Test::Unit::TestCase
+  def test_gen_should_create_a_given_length_random_string
+    length = 8
+    token = RandomToken.gen(length)
+    assert_match(/^.{#{length}}$/, token)
+  end
+end

data/test/length/test_mask.rb

@@ -0,0 +1,30 @@
+require "test/unit"
+require "random_token"
+
+class TestMask < Test::Unit::TestCase
+  def test_gen_should_use_given_mask
+    length = 10000
+    mask = ['a','b','c','d','e','0','1','2','3','4']
+    token = RandomToken.gen(length, :mask => mask)
+    assert((token.split(//).uniq - mask) == token.split(//).uniq)
+    token = RandomToken.gen(length, :m => mask)
+    assert((token.split(//).uniq - mask) == token.split(//).uniq)
+  end
+
+  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,
+                                                                              :friendly => false) }
+    assert(e.code == :false_friendly_with_given_mask)
+  end
+
+  def test_gen_should_raise_an_exception_if_mask_remove_all_seeds
+    length = 10000
+    seed = ['a']
+    mask = ['a']
+    e = assert_raise(RandomToken::RandomTokenError) { RandomToken.gen(length, :seed => seed,
+                                                                              :mask => mask) }
+    assert(e.code == :mask_remove_all_seeds)
+  end
+end

data/test/length/test_seed.rb

@@ -0,0 +1,106 @@
+require "test/unit"
+require "random_token"
+
+class TestSeed < Test::Unit::TestCase
+  def test_gen_should_create_a_random_with_alphabets_only
+    length = 10000
+    token = RandomToken.gen(length, :seed => :a)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :seed => :alphabet)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :seed => :l)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :seed => :letter)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :s => :a)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :s => :alphabet)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :s => :l)
+    assert_match(/^[A-Za-z]*$/, token)
+    token = RandomToken.gen(length, :s => :letter)
+    assert_match(/^[A-Za-z]*$/, 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)
+    token = RandomToken.gen(length, :seed => :number)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :seed => 1)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :seed => 10)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :s => :n)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :s => :number)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :s => 1)
+    assert_match(/^[0-9]*$/, token)
+    token = RandomToken.gen(length, :s => 10)
+    assert_match(/^[0-9]*$/, 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)
+    token = RandomToken.gen(length, :seed => :binary)
+    assert_match(/^[01]*$/, token)
+    token = RandomToken.gen(length, :seed => 2)
+    assert_match(/^[01]*$/, token)
+    token = RandomToken.gen(length, :s => :b)
+    assert_match(/^[01]*$/, token)
+    token = RandomToken.gen(length, :s => :binary)
+    assert_match(/^[01]*$/, token)
+    token = RandomToken.gen(length, :s => 2)
+    assert_match(/^[01]*$/, 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)
+    token = RandomToken.gen(length, :seed => :oct)
+    assert_match(/^[0-7]*$/, token)
+    token = RandomToken.gen(length, :seed => 8)
+    assert_match(/^[0-7]*$/, token)
+    token = RandomToken.gen(length, :s => :o)
+    assert_match(/^[0-7]*$/, token)
+    token = RandomToken.gen(length, :s => :oct)
+    assert_match(/^[0-7]*$/, token)
+    token = RandomToken.gen(length, :s => 8)
+    assert_match(/^[0-7]*$/, 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)
+    token = RandomToken.gen(length, :seed => :hex)
+    assert_match(/^[0-9A-F]*$/, token)
+    token = RandomToken.gen(length, :seed => 16)
+    assert_match(/^[0-9A-F]*$/, token)
+    token = RandomToken.gen(length, :s => :h)
+    assert_match(/^[0-9A-F]*$/, token)
+    token = RandomToken.gen(length, :s => :hex)
+    assert_match(/^[0-9A-F]*$/, token)
+    token = RandomToken.gen(length, :s => 16)
+    assert_match(/^[0-9A-F]*$/, token)
+  end
+
+  def test_gen_should_create_a_random_with_given_seeds
+    length = 10000
+    seeds = ['a', 'b', 'c', '1', '2', '3', '!', '@', '#', '$', '%',
+             '^', '&', '*', '(', ')', '-', '_', '=', '+', '{', '}',
+             '[', ']', '\\', '|', ';', ':', '\'', '"', ',', '<',
+             '.', '>', '/', '?', '`', '~']
+    token = RandomToken.gen(length, :seed => seeds)
+    targets = "[#{Regexp.escape(seeds.join)}]"
+    assert_match(/^#{targets}*$/, token)
+    token = RandomToken.gen(length, :s => seeds)
+    targets = "[#{Regexp.escape(seeds.join)}]"
+    assert_match(/^#{targets}*$/, token)
+  end
+end

data/test/test_all.rb

@@ -3,6 +3,6 @@ require "test/unit"
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"
 require "random_token"
+require "test_gen"
 require "test_get"
 require "test_strf"
-require "test_gen"

data/test/test_gen.rb

@@ -3,10 +3,29 @@ require "test/unit"
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"
 require "random_token"
+require "length/test_length"
+require "length/test_case"
+require "length/test_friendly"
+require "length/test_seed"
+require "length/test_mask"
+require "length/test_hash_seed"
+require "format/test_pattern"
+require "format/test_percent"
 
 class TestGen < Test::Unit::TestCase
   def test_gen_should_raise_an_exception_if_the_given_arg_is_invalid
     e = assert_raise(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) }
+    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) }
+    assert(e.code == :invalid_option_value)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: random_token
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-28 00:00:00.000000000 Z
+date: 2013-10-03 00:00:00.000000000 Z
 dependencies: []
 description: A simple way to generate a random token.
 email:
@@ -24,12 +24,20 @@ files:
 - lib/random_token/random_token_error.rb
 - lib/random_token/version.rb
 - random_token.gemspec
+- test/format/test_pattern.rb
+- test/format/test_percent.rb
 - test/get/test_case.rb
 - test/get/test_friendly.rb
 - test/get/test_hash_seed.rb
 - test/get/test_length.rb
 - test/get/test_mask.rb
 - test/get/test_seed.rb
+- test/length/test_case.rb
+- test/length/test_friendly.rb
+- test/length/test_hash_seed.rb
+- test/length/test_length.rb
+- test/length/test_mask.rb
+- test/length/test_seed.rb
 - test/strf/test_pattern.rb
 - test/strf/test_percent.rb
 - test/test_all.rb
@@ -58,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: ! 'Use "gen" method to create a random token with a given length.  RandomToken.gen(8)
@@ -67,12 +75,20 @@ summary: ! 'Use "gen" method to create a random token with a given length.  Rand
   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
 - test/get/test_case.rb
 - test/get/test_friendly.rb
 - test/get/test_hash_seed.rb
 - test/get/test_length.rb
 - test/get/test_mask.rb
 - test/get/test_seed.rb
+- test/length/test_case.rb
+- test/length/test_friendly.rb
+- test/length/test_hash_seed.rb
+- test/length/test_length.rb
+- test/length/test_mask.rb
+- test/length/test_seed.rb
 - test/strf/test_pattern.rb
 - test/strf/test_percent.rb
 - test/test_all.rb
@@ -80,4 +96,3 @@ test_files:
 - test/test_get.rb
 - test/test_helper.rb
 - test/test_strf.rb
-has_rdoc: