random_token 1.0.0

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sibevin Wang
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,224 @@
+# Random Token
+
+A simple way to generate a random token.
+
+    jjukoguwegcvclkuhljvsblrpfnd
+    je         dzl            pu
+    qu  yrllvr  bsnehow  pplshyo
+    sw  hwzedi  cnjdpqw  pnuctvl
+    fY  sJmss  msg2Qpbx  7sgtFpD
+    5V        90Ofl83da  3TQ6fQj
+    il  q93H  GLpCNvakC  Fd0ppyd
+    QW  TWZLX  WFQUWYMD  MJSYRJI
+    IX  AIVBZI  andomPR  okenYIN
+    DRRJVYVMEVREBFYXLLFQGISGAGED
+
+## Usage
+
+### Basic
+
+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. Please read "Format" below to get more details.
+
+    RandomToken.gen("Give me a token %8?")
+    # "Give me a token 6HRQZp8O"
+
+### Seed
+
+Use `:seed` option to customize the random characters.
+
+Use `:a` (or `:alphabet`, `:l`, `:letter`) to create a token with alphabets.
+
+    RandomToken.gen(32, :seed => :a)
+    # "DTVbCnRldQnLAoERHAzjLOTJBTWoBGQb"
+
+Use `:n` (or `:number`, `10`, `1`) to create a token with numbers.
+
+    RandomToken.gen(32, :seed => :n)
+    # "41107838709625922353782552721916"
+
+Use `:b` (or `:binary`, `2`) to create a binary token.
+
+    RandomToken.gen(32, :seed => :b)
+    # "11101001110110110000101101010101"
+
+Use `:o` (or `:oct`, 8) to create a octal token.
+
+    RandomToken.gen(32, :seed => :o)
+    # "57531726664723324643140173424423"
+
+Use `:h` (or `:hex`, 16) to create a hexadecimal token.
+
+    RandomToken.gen(32, :seed => :h)
+    # "B7E1FD250D250008314496AE48EDE310"
+
+Use an `array` to customize random seeds.
+
+    RandomToken.gen(32, :seed => ['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 })
+    # "bbabbaaaabaabbbabbbbbbbbbaababbb"
+
+### Friendly
+
+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*.
+
+    RandomToken.gen(32, :friendly => true)
+    # "fjx5WTb4wbPmbwb7b4szzY4szfrqtJLj"
+
+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::RandomTokenError: RandomToken::RandomTokenError
+
+Use `: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'])
+    # "QlHhMpfrGnOykMS8tpfYrW0EnqvRsItw"
+
+### Case
+
+Use `:case` option to modify the token case.
+
+Use `:u` (or `:up`) to create an upper-case token.
+
+    RandomToken.gen(32, :case => :u)
+    # "YKNOAMC5FQZTMRS9U3SI4U9QWEMU7TLL"
+
+Use `:d` (or `:down`) to create a down-case token.
+
+    RandomToken.gen(32, :case => :d)
+    # "8fvs6dfxko4buxcho23vz5jpxw9arj7t"
+
+Use `:m` (or `:mixed`) to create a mixed-case token. It is the default option.
+
+    RandomToken.gen(32, :case => :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::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.
+
+    RandomToken.gen(32, :seed => :h, :case => :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 }) }
+
+    ............................
+    .......................O.o..
+    ............................
+    ........................_...
+    .....o...............O......
+    ............................
+    ............................
+    ............................
+    .........o....O.............
+    .o..........................
+
+Is it a desert? Of course!! . = sand, o = small stone, O = large stone, and _ = oasis.
+
+Oh..., I think I am not a man of imagination like you...
+
+### Case 2
+
+How to create a cool logo?
+
+    puts RandomToken.gen("%28a\n%2a#{' '*9}%3a#{' '*12}%2a\n%2a  %6a  %7a  %7a\n%2a  %6a  %7a  %7a\n%2?  %5?  %8?  %7?\n%2?#{' '*8}%9?  %7?\n%2?  %4?  %9?  %7?\n%2A  %5A  %8A  %7A\n%2A  %6A  andom%2A  oken%3A\n%28A")
+
+    ieqccitkalecvbfehlfbkejdthxc
+    kt         vhk            mw
+    mt  rktuhx  wvniunx  yckqxih
+    gu  mbrjdf  ratkfyj  oxcvtle
+    F7  tFpoz  8QZpLT1Y  vxNl778
+    VZ        gXqKqXDkr  Nx1j0Ig
+    n9  ee7s  UeDOXLl3D  pxf6mgH
+    VM  QGSPP  VAJCAVDM  UJRCCXP
+    KC  TMWEVM  andomAX  okenQNE
+    NMVJJAXHHAPLDSYNHCXILCFWYAQA
+
+Uh, I don't think it is cool enough...
+
+## Test
+
+Go to random_token gem folder and run
+
+    ruby ./test/test_all.rb
+
+## Authors
+
+Sibevin Wang
+
+## Copyright
+
+Copyright (c) 2013 Sibevin Wang. Released under the MIT license.

data/lib/random_token.rb

@@ -0,0 +1,229 @@
+require "random_token/random_token_error"
+
+module RandomToken
+
+  # The number seed
+  NUMBERS = ('0'..'9')
+
+  # The alphabet seed
+  ALPHABETS = ('A'..'Z')
+
+  # The default friendly mask
+  MASK = ['1', 'I', 'l', 'i', '0', 'O', 'o', 'Q', 'D',
+          'C', 'c', 'G', '9', '6', 'U', 'u', 'V', 'v',
+          'E', 'F', 'M', 'N', '8', 'B']
+
+  # The default option definition
+  DEFAULT_OPT = {
+    :seed => nil,
+    :friendly => false,
+    :case => :mixed
+  }
+
+  # The default seeds definition
+  SEED_TYPES = {
+    :default => {
+      :abbr => [nil],
+      :seed => [NUMBERS, ALPHABETS],
+      :support_friendly => true,
+      :support_case => true,
+      :default_case => :mixed
+    },
+    :alphabet => {
+      :abbr => [:letter, :a, :l],
+      :seed => [ALPHABETS],
+    },
+    :number => {
+      :abbr => [:n, 1, 10],
+      :seed => [NUMBERS],
+      :support_case => false
+    },
+    :binary => {
+      :abbr => [:b, 2],
+      :seed => [('0'..'1')],
+      :support_case => false,
+      :support_friendly => false
+    },
+    :oct => {
+      :abbr => [:o, 8],
+      :seed => [('0'..'7')],
+      :support_case => false,
+      :support_friendly => false
+    },
+    :hex => {
+      :abbr => [:h, 16],
+      :seed => [NUMBERS, ('A'..'F')],
+      :support_friendly => false,
+      :default_case => :up
+    }
+  }
+
+  # The directives used in the {RandomToken.strf} method.
+  STRF_ARG_MAP = {
+    'A' => { :seed => :alphabet, :case => :up },
+    'a' => { :seed => :alphabet, :case => :down },
+    'n' => { :seed => :number },
+    'b' => { :seed => :binary },
+    'o' => { :seed => :oct },
+    'h' => { :seed => :hex, :case => :down },
+    'H' => { :seed => :hex, :case => :up },
+    'X' => { :case => :up },
+    'x' => { :case => :down },
+    '?' => {}
+  }
+
+  class << self
+    # The major method to generate a random token. It would call {RandomToken.get} or {RandomToken.strf} according to the given arg.
+    # @param arg [Fixnum, String]
+    #   To give a token length or the string format for generating token.
+    # @param options [Hash]
+    #   The options to modify the token.
+    #   Three options :seed, :friendly and :case are supported.
+    #   Please see {file:README} to get more examples
+    # @return [String]
+    #   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)
+      end
+    end
+
+    # A convenient method to generate a friendly token. It would call {RandomToken.gen} with :friendly => true option.
+    # @param arg (see RandomToken.gen)
+    # @param options (see RandomToken.gen)
+    # @return (see RandomToken.gen)
+    # @raise (see RandomToken.gen)
+    def genf(arg, options = {})
+      gen(arg, { :friendly => true }.merge(options))
+    end
+
+    # To generate a random token with a given length.
+    # @param length [Fixnum]
+    #   The token length.
+    # @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
+    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.
+    # @param options (see RandomToken.gen)
+    # @return (see RandomToken.gen)
+    # @raise (see RandomToken.gen)
+    def strf(pattern, options = {})
+      in_arg = false
+      result = ''
+      length = ''
+      pattern.split(//).each do |x|
+        if x == '%'
+          if in_arg
+            result << x * (length == "" ? 1 : length.to_i)
+            length = ''
+            in_arg = false
+          else
+            in_arg = true
+          end
+        elsif ('0'..'9').include?(x)
+          if in_arg
+            length << x
+          else
+            result << x
+          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))
+            length = ''
+            in_arg = false
+          else
+            result << x
+          end
+        else
+          if in_arg
+            raise RandomTokenError.new(:invalid_strf_pattern, pattern)
+          else
+            result << x
+          end
+        end
+      end
+      result
+    end
+
+    private
+
+    # To generate seeds according to the :seed options
+    def gen_seeds(opt)
+      opt_seed = opt[:seed]
+      default_opt = SEED_TYPES[:default]
+      if opt_seed == nil || opt_seed.is_a?(Symbol) || opt_seed.is_a?(Fixnum)
+        SEED_TYPES.each do |key, value|
+          if ([key] + value[:abbr]).include?(opt_seed)
+            opt.delete(:seed)
+            opt = default_opt.merge(value).merge(opt)
+            opt[:seed] = opt[:seed].map { |s| s.to_a }.flatten
+            return seed_modifier(opt)
+          end
+        end
+        raise RandomTokenError.new(:unknown_seed, opt_seed)
+      elsif opt_seed.is_a?(Array)
+        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 ))
+      else
+        raise RandomTokenError.new(:unknown_seed, opt_seed)
+      end
+    end
+
+    # To 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]
+        case case_opt
+          when :up, :u 
+            cased_seed = opt[:seed].map { |s| s.upcase }
+          when :down, :d, :lower, :l
+            cased_seed = opt[:seed].map { |s| s.downcase }
+          when :mixed, :m
+            cased_seed = opt[:seed].map { |s| [s.upcase, s.downcase] }.flatten
+          else
+            # :keep, keep the seed case
+            cased_seed = opt[:seed]
+        end
+        opt[:seed] = cased_seed.uniq
+      else
+        raise RandomTokenError.new(:not_support_case, opt) if opt[:case] != nil
+      end
+      if opt[:support_friendly] 
+        if opt[:friendly] || (opt[:friendly] == nil && opt[:mask])
+          masked_seed = opt[:seed].dup
+          mask = opt[:mask] || MASK
+          mask.each { |m| masked_seed.delete(m) }
+          opt[:seed] = masked_seed
+        elsif opt[:friendly] == false && opt[:mask]
+          raise RandomTokenError.new(:false_friendly_with_given_mask, opt)
+        end
+      else
+        if opt[:friendly] == true || opt[:mask] != nil
+          raise RandomTokenError.new(:not_support_friendly, opt)
+        end
+      end
+      raise RandomTokenError.new(:mask_remove_all_seeds, opt) if opt[:seed] == []
+      opt
+    end
+  end
+end

data/lib/random_token/random_token_error.rb

@@ -0,0 +1,67 @@
+module RandomToken
+
+  # A customized exception for RandomToken
+  class RandomTokenError < StandardError
+
+    # Errors used in RandomToken
+    ERRORS = {
+      :unknown_seed => {
+        :value => 1,
+        :msg => "Unknown given seed"
+      },
+      :not_support_case => {
+        :value => 2,
+        :msg => "Case feature is not supported in this case, but the case option is given."
+      },
+      :not_support_friendly => {
+        :value => 3,
+        :msg => "Friendly feature is not supported in this case, but the friendly option is true."
+      },
+      :false_friendly_with_given_mask => {
+        :value => 4,
+        :msg => "The mask is given but the friendly option is false."
+      },
+      :invalid_strf_pattern => {
+        :value => 5,
+        :msg => "The given pattern is invalid."
+      },
+      :invalid_gen_arg => {
+        :value => 6,
+        :msg => "The given arg is invalid."
+      },
+      :mask_remove_all_seeds => {
+        :value => 7,
+        :msg => "The friendly mask removes all seeds."
+      }
+    }
+
+    attr_reader :code, :value, :msg, :info
+
+    # The RandomTokenError constructor.
+    # @param error [Fixnum, String]
+    #   You can give a error number defined in the keys of {RandomToken::RandomTokenError::ERRORS} or a string message for internal usage.
+    # @param info [Hash]
+    #   Anything you want to put in the info attribute of RandomTokenError.
+    def initialize(error, info = {})
+      @code = error
+      @info = info
+      if ERRORS.keys.include?(error)
+        @value = ERRORS[error][:value]
+        @msg = ERRORS[error][:msg]
+      elsif error.class.name == 'String'
+        @code = :internal
+        @value = 90000
+        @msg = error
+      else
+        @code = :internal
+        @value = 99999
+        @msg = "Internal Error"
+      end
+    end
+
+    # Override the message method to show more information in RandomTokenError
+    def message
+      "RandomTokenError(#{@code.to_s}): value = #{@value}, msg = #{@msg}, info = #{@info.inspect}"
+    end
+  end
+end

data/lib/random_token/version.rb

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

data/random_token.gemspec

@@ -0,0 +1,34 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'random_token/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "random_token"
+  spec.version       = RandomToken::VERSION
+  spec.authors       = ["Sibevin Wang"]
+  spec.email         = ["sibevin@gmail.com"]
+  spec.description   = %q{A simple way to generate a random token.}
+  spec.summary       = <<-EOF
+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.
+  EOF
+  spec.homepage      = "https://github.com/sibevin/random_token"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+end

data/test/get/test_case.rb

@@ -0,0 +1,45 @@
+require "test/unit"
+require "random_token"
+
+class TestCase < Test::Unit::TestCase
+  def test_get_should_create_a_random_with_upper_case_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.get(length, :case => :up)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+    token = RandomToken.get(length, :case => :u)
+    assert_match(/^[A-Z0-9]{#{length}}$/, token)
+  end
+
+  def test_get_should_create_a_random_with_lower_case_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.get(length, :case => :down)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+    token = RandomToken.get(length, :case => :d)
+    assert_match(/^[a-z0-9]{#{length}}$/, token)
+  end
+
+  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) }
+    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) }
+    assert(e.code == :not_support_case)
+  end
+
+  def test_get_should_use_upper_case_by_default_when_creating_hexdecimal_random
+    length = 10000
+    token = RandomToken.get(length, :seed => :h)
+    assert_match(/^[0-9A-F]*$/, token)
+  end
+
+  def test_get_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.get(length, :seed => seeds)
+    assert_match(/^#{"[#{Regexp.escape(seeds.join)}]"}*$/, token)
+  end
+end

data/test/get/test_friendly.rb

@@ -0,0 +1,35 @@
+require "test/unit"
+require "random_token"
+
+class TestFriendly < Test::Unit::TestCase
+  def test_get_should_not_create_a_random_including_masked_alphabets_or_numbers
+    length = 10000
+    token = RandomToken.get(length, :friendly => true)
+    assert((RandomToken::MASK - token.split(//).uniq) == RandomToken::MASK)
+  end
+
+  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) }
+    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) }
+    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) }
+    assert(e.code == :not_support_friendly)
+  end
+
+  def test_get_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.get(length, :seed => seeds, :friendly => true)
+    assert((token.split(//).uniq - RandomToken::MASK) == token.split(//).uniq)
+  end
+end

data/test/get/test_hash_seed.rb

@@ -0,0 +1,36 @@
+require "test/unit"
+require "random_token"
+
+class TestHashSeed < Test::Unit::TestCase
+  def test_get_should_create_a_random_with_the_given_seeds
+    length = 10000
+    token = RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 })
+    assert_match(/^[a-c]{#{length}}$/, token)
+  end
+
+  def test_get_should_create_a_random_with_the_given_distribution_of_seeds
+    length = 1000000
+    token = RandomToken.get(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_get_should_not_support_case_feature_when_given_the_hash_seed
+    length = 10000
+    e = assert_raise(RandomToken::RandomTokenError) { 
+      RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :case => :up)
+    }
+    assert(e.code == :not_support_case)
+  end
+
+  def test_get_should_not_support_friendly_feature_when_given_the_hash_seed
+    length = 10000
+    e = assert_raise(RandomToken::RandomTokenError) { 
+      RandomToken.get(length, :seed => { 'a' => 1, 'b' => 2, 'c' => 3 }, :friendly => true)
+    }
+    assert(e.code == :not_support_friendly)
+  end
+end

data/test/get/test_length.rb

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

data/test/get/test_mask.rb

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

data/test/get/test_seed.rb

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

data/test/strf/test_pattern.rb

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

data/test/strf/test_percent.rb

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

data/test/test_all.rb

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

data/test/test_gen.rb

@@ -0,0 +1,12 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "random_token"
+
+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
+end

data/test/test_get.rb

@@ -0,0 +1,11 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "random_token"
+require "get/test_length"
+require "get/test_case"
+require "get/test_friendly"
+require "get/test_seed"
+require "get/test_mask"
+require "get/test_hash_seed"

data/test/test_helper.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")

data/test/test_strf.rb

@@ -0,0 +1,7 @@
+require "test/unit"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "random_token"
+require "strf/test_pattern"
+require "strf/test_percent"

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: random_token
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sibevin Wang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-07-28 00:00:00.000000000 Z
+dependencies: []
+description: A simple way to generate a random token.
+email:
+- sibevin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/random_token.rb
+- lib/random_token/random_token_error.rb
+- lib/random_token/version.rb
+- random_token.gemspec
+- 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/strf/test_pattern.rb
+- test/strf/test_percent.rb
+- test/test_all.rb
+- test/test_gen.rb
+- test/test_get.rb
+- test/test_helper.rb
+- test/test_strf.rb
+homepage: https://github.com/sibevin/random_token
+licenses:
+- MIT
+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.25
+signing_key: 
+specification_version: 3
+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.'
+test_files:
+- 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/strf/test_pattern.rb
+- test/strf/test_percent.rb
+- test/test_all.rb
+- test/test_gen.rb
+- test/test_get.rb
+- test/test_helper.rb
+- test/test_strf.rb
+has_rdoc: