shokkenki-support 0.0.2 → 0.0.3

data/lib/shokkenki/support/version.rb

@@ -1,7 +1,7 @@
 module Shokkenki
   module Support
     module Version
-      STRING = '0.0.2'
+      STRING = '0.0.3'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shokkenki-support
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-26 00:00:00.000000000 Z
+date: 2013-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -113,9 +113,6 @@ files:
 - lib/shokkenki/term/string_term.rb
 - lib/shokkenki/term/term.rb
 - lib/shokkenki/term/term_factory.rb
-- lib/shokkenki/term/ruby-string-random/lib/strrand.rb
-- lib/shokkenki/term/ruby-string-random/README
-- lib/shokkenki/term/ruby-string-random/test/test_strrand.rb
 homepage: http://github.com/brentsnook/shokkenki-support
 licenses:
 - GPL2
@@ -138,11 +135,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2074170128590300944
+      hash: 3238517007321891354
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: shokkenki-support-0.0.2
+summary: shokkenki-support-0.0.3
 test_files: []

data/lib/shokkenki/term/ruby-string-random/README

@@ -1,15 +0,0 @@
-# About StringRandom
-
-StringRandom generate a random string based on Regexp syntax or Patterns.
-StringRandom is Ruby version of String::Random written in Perl.
-The original code released in http://search.cpan.org/~steve/String-Random-0.22/
-
-# How to use
-
-Exmaples are written in test_strrand.rb.
-
-# Copyright
-
-    Copyright (c) 2008 Masahiro Nakagawa
-
-This library is released under the Ruby license.

data/lib/shokkenki/term/ruby-string-random/lib/strrand.rb

@@ -1,302 +0,0 @@
-#
-# = strrand.rb: Generates a random string from a pattern
-#
-# Author:: tama <repeatedly@gmail.com>
-#
-# StringRandom is derived from the String::Random written in Perl.
-# See http://search.cpan.org/~steve/String-Random-0.22/
-#
-# == Example
-#
-#   string_random = StringRandom.new
-#   string_random.random_pattern('CCcc!ccn')  #=> ZIop$ab1
-#
-# refer to test/test_stringrandom.rb
-#
-# == Format
-#
-# === Regular expression syntax
-#
-# *_regex methods use this rule.
-#
-# The following regular expression elements are supported.
-#
-# [\w]  Alphanumeric + "_".
-# [\d]  Digits.
-# [\W]  Printable characters other than those in \w.
-# [\D]  Printable characters other than those in \d.
-# [.]   Printable characters.
-# [[]]  Character classes.
-# [{}]  Repetition.
-# [*]   Same as {0,}.
-# [+]   Same as {1,}
-# [?]   Same as {0,1}.
-#
-# === Patterns
-#
-# random_pattern and random_string methods use this rule.
-#
-# The following patterns are pre-defined.
-#
-# [c]  Any lowercase character [a-z]
-# [C]  Any uppercase character [A-Z]
-# [n]  Any digit [0-9]
-# [!]  A punctuation character [~`!@$%^&*()-_+={}[]|\:;"'.<>?/#,]
-# [.]  Any of the above
-# [s]  A "salt" character [A-Za-z0-9./]
-# [b]  Any binary data
-#
-# Pattern can modify and add as bellow.
-#
-#   string_random['C'] = ['n']
-#   string_random['A'] = Array('A'..'Z') | Array('a'..'z')
-#
-# Pattern must be a flattened array that elements are one character.
-# Other types cause undefined behavior(raise exception, success, etc...).
-#
-class StringRandom
-  Upper  = Array('A'..'Z')
-  Lower  = Array('a'..'z')
-  Digit  = Array('0'..'9')
-  Punct  = [33..47, 58..64, 91..96, 123..126].map { |r| r.map { |val| val.chr } }.flatten
-  Any    = Upper | Lower | Digit | Punct
-  Salt   = Upper | Lower | Digit | ['.', '/']
-  Binary = (0..255).map { |val| val.chr }
-
-  # These are the regex-based patterns.
-  Pattern = {
-    # These are the regex-equivalents.
-    '.'  => Any,
-    '\d' => Digit,
-    '\D' => Upper | Lower | Punct,
-    '\w' => Upper | Lower | Digit | ['_'],
-    '\W' => Punct.reject { |val| val == '_' },
-    '\s' => [' ', "\t"],
-    '\S' => Upper | Lower | Digit | Punct,
-
-    # These are translated to their double quoted equivalents.
-    '\t' => ["\t"],
-    '\n' => ["\n"],
-    '\r' => ["\r"],
-    '\f' => ["\f"],
-    '\a' => ["\a"],
-    '\e' => ["\e"]
-  }
-  # These are the old patterns for random_pattern.
-  OldPattern = {
-    'C' => Upper,
-    'c' => Lower,
-    'n' => Digit,
-    '!' => Punct,
-    '.' => Any,
-    's' => Salt,
-    'b' => Binary
-  }
-
-  #
-  # Singleton method version of random_regex.
-  #
-  def self.random_regex(patterns)
-    StringRandom.new.random_regex(patterns)
-  end
-
-  #
-  # Same as StringRandom#random_pattern if single argument.
-  # Optionally, references to lists containing 
-  # other patterns can be passed to the function.  
-  # Those lists will be used for 0 through 9 in the pattern. 
-  #
-  def self.random_string(pattern, *pattern_list)
-    string_random = StringRandom.new
-
-    pattern_list.each_with_index do |new_pattern, i|
-      string_random[i.to_s] = new_pattern
-    end
-
-    string_random.random_pattern(pattern)
-  end
-
-  #
-  # _max_ is default length for creating random string
-  #
-  def initialize(max = 10)
-    @max   = max
-    @map   = OldPattern.clone
-    @regch = {
-      "\\" => method(:regch_slash),
-      '.'  => method(:regch_dot),
-      '['  => method(:regch_bracket),
-      '*'  => method(:regch_asterisk),
-      '+'  => method(:regch_plus),
-      '?'  => method(:regch_question),
-      '{'  => method(:regch_brace)
-    }
-  end
-
-  #
-  # Returns a random string that will match 
-  # the regular expression passed in the list argument.
-  #
-  def random_regex(patterns)
-    return _random_regex(patterns) unless patterns.instance_of?(Array)
-
-    result = []
-    patterns.each do |pattern|
-      result << _random_regex(pattern)
-    end
-    result
-  end
-
-  #
-  # Returns a random string based on the concatenation
-  # of all the pattern strings in the list.
-  #
-  def random_pattern(patterns)
-    return _random_pattern(patterns) unless patterns.instance_of?(Array)
-
-    result = []
-    patterns.each do |pattern|
-      result << _random_pattern(pattern)
-    end
-    result
-  end
-
-  #
-  # Returns a random string pattern
-  #
-  def [](key)
-    @map[key]
-  end
-
-  #
-  # Adds a random string pattern
-  #
-  # _pattern_ must be flattened array
-  #
-  def []=(key, pattern)
-    @map[key] = pattern
-  end
-
-  private
-
-  def _random_regex(pattern)
-    string = []
-    chars  = pattern.split(//)
-    non_ch = /[\$\^\*\(\)\+\{\}\]\|\?]/  # not supported chars
-
-    while ch = chars.shift
-      if @regch.has_key?(ch)
-        @regch[ch].call(ch, chars, string)
-      else
-        warn "'#{ch}' not implemented. treating literally." if ch =~ non_ch
-        string << [ch]
-      end
-    end
-
-    result = ''
-    string.each do |ch|
-      result << ch[rand(ch.size)]
-    end
-    result
-  end
-
-  def _random_pattern(pattern)
-    string = ''
-
-    pattern.split(//).each do |ch|
-      raise %Q(Unknown pattern character "#{ch}"!) unless @map.has_key?(ch)
-      string << @map[ch][rand(@map[ch].size)]
-    end
-
-    string
-  end
-
-  #-
-  # The folloing methods are defined for regch.
-  # These characters are treated specially in random_regex.
-  #+
-
-  def regch_slash(ch, chars, string)
-    raise 'regex not terminated' if chars.empty?
-
-    tmp = chars.shift
-    if tmp == 'x'
-      # This is supposed to be a number in hex, so
-      # there had better be at least 2 characters left.
-      tmp = chars.shift + chars.shift
-      string << tmp.hex.chr
-    elsif tmp =~ /[0-7]/
-      warn 'octal parsing not implemented. treating literally.'
-      string << tmp
-    elsif Pattern.has_key?(ch + tmp)
-      string << Pattern[ch + tmp]
-    else
-      warn "'\\#{tmp}' being treated as literal '#{tmp}'"
-      string << tmp
-    end
-  end
-
-  def regch_dot(ch, chars, string)
-    string << Pattern[ch]
-  end
-
-  def regch_bracket(ch, chars, string)
-    tmp = []
-
-    while ch = chars.shift and ch != ']'
-      if ch == '-' and !chars.empty? and !tmp.empty?
-        max  = chars.shift
-        min  = tmp.last
-        tmp << min = min.succ while min < max
-      else
-        warn "${ch}' will be treated literally inside []" if ch =~ /\W/
-        tmp << ch
-      end
-    end
-    raise 'unmatched []' if ch != ']'
-
-    string << tmp
-  end
-
-  def regch_asterisk(ch, chars, string)
-    chars = '{0,}'.split('').concat(chars)
-  end
-
-  def regch_plus(ch, chars, string)
-    chars = '{1,}'.split('').concat(chars)
-  end
-
-  def regch_question(ch, chars, string)
-    chars = '{0,1}'.split('').concat(chars)
-  end
-
-  def regch_brace(ch, chars, string)
-    # { isn't closed, so treat it literally.
-    return string << ch unless chars.include?('}')
-
-    tmp = ''
-    while ch = chars.shift and ch != '}'
-      raise "'#{ch}' inside {} not supported" unless ch =~ /[\d,]/
-      tmp << ch
-    end
-
-    tmp = if tmp =~ /,/
-      raise "malformed range {#{tmp}}" unless tmp =~ /^(\d*),(\d*)$/
-
-      min = $1.length.nonzero? ? $1.to_i : 0
-      max = $2.length.nonzero? ? $2.to_i : @max
-      raise "bad range {#{tmp}}" if min > max
-
-      min == max ? min : min + rand(max - min + 1)
-    else
-      tmp.to_i
-    end
-
-    if tmp.nonzero?
-      last = string.last
-      (tmp - 1).times { string << last }
-    else
-      string.pop
-    end
-  end
-end

data/lib/shokkenki/term/ruby-string-random/test/test_strrand.rb

@@ -1,180 +0,0 @@
-#
-# test/test_strrand.rb
-#
-
-$KCODE      = 'u' if RUBY_VERSION < '1.9.0'
-$LOAD_PATH << '../'
-
-require 'lib/strrand'
-require 'test/unit'
-
-class TestStringRandom < Test::Unit::TestCase
-  def setup
-    @string_random = StringRandom.new
-  end
-
-  # StringRandom itself
-  def test_initialize
-    assert_not_nil(@string_random)
-    assert_instance_of(StringRandom, @string_random)
-  end
-
-  # StringRandom methods
-  def test_method_respond
-    # instance methods
-    assert_respond_to(@string_random, :[])
-    assert_respond_to(@string_random, :[]=)
-    assert_respond_to(@string_random, :random_regex)
-    assert_respond_to(@string_random, :random_pattern)
-
-    # singleton methods
-    assert_respond_to(StringRandom, :random_regex)
-    assert_respond_to(StringRandom, :random_string)
-  end
-
-  # StringRandom#random_regex
-  def test_random_regex
-    patterns = ['\d\d\d',
-                '\w\w\w',
-                '[ABC][abc]',
-                '[012][345]',
-                '...',
-                '[a-z][0-9]',
-                '[aw-zX][123]',
-                '[a-z]{5}',
-                '0{80}',
-                '[a-f][nprt]\d{3}',
-                '\t\n\r\f\a\e',
-                '\S\S\S',
-                '\s\s\s',
-                '\w{5,10}',
-                '\w?',
-                '\w+',
-                '\w*',
-                '']
-
-    patterns.each do |pattern|
-      result = @string_random.random_regex(pattern)
-      assert_match(/#{pattern}/, result, "#{result} is invalid: pattern #{pattern}")
-    end
-
-    result = @string_random.random_regex(patterns)
-    assert_equal(patterns.size, result.size)
-  end
-
-  # StringRandom#random_regex
-  def test_random_regex_invalid
-    patterns = ['[a-z]{a}',
-                '0{,,}',
-                '9{1,z}']
-
-    patterns.each do |pattern|
-      assert_raise(RuntimeError, "Non expected: #{pattern}") { @string_random.random_regex(pattern) }
-    end
-  end
-
-  # StringRandom#random_pattern
-  def test_random_pattern
-    assert_equal(0, @string_random.random_pattern('').length)
-
-    patterns = {
-      'x' => ['a'],
-      'y' => ['b'],
-      'z' => ['c']
-    }
-
-    patterns.each_pair do |key, pattern|
-      @string_random[key] = pattern
-    end
-    assert_equal('abc', @string_random.random_pattern('xyz'))
-
-    target = patterns.keys
-    result = @string_random.random_pattern(target)
-    assert_equal(target.size, result.size)
-    target.each_with_index do |pattern, i|
-      assert_equal(@string_random[pattern][0], result[i])
-    end
-  end
-
-  # StringRandom#random_pattern
-  def test_random_pattern_builtin
-    ['C', 'c', 'n', '!', '.', 's', 'b'].each do |val|
-      assert_not_nil(@string_random[val])
-    end
-
-    range = ('A'..'Z').to_a
-    range.each_with_index do |val, i|
-      assert_equal(val, @string_random['C'][i])
-    end
-
-    # modify built-in pattern
-    @string_random['C'] = ['n']
-    assert_equal('n', @string_random.random_pattern('C'))
-
-    # undefined behavior
-    count    = 0
-    patterns = {
-      'X' => ('A'..'Z'),
-      'Y' => [['foo,', 'bar'], [['baz']]],
-      'Z' => [true, false],
-      ''  => 'hogehoge' # no raise
-    }
-    patterns.each_pair do |key, pattern|
-      begin
-        @string_random[key] = pattern
-        @string_random.random_pattern(key)
-      rescue Exception
-        count += 1
-      end
-    end
-    assert_equal(patterns.keys.size - 1, count)
-
-    # No pollute other object
-    @other = StringRandom.new
-    assert_not_equal('n', @other.random_pattern('C'))
-  end
-
-  # StringRandom#random_pattern
-  def test_random_pattern_invalid
-    ['A', 'CZ1s', 'Hoge', '\n'].each do |pattern|
-      assert_raise(RuntimeError) { @string_random.random_pattern(pattern) }
-    end
-  end
-
-  # StringRandom.random_regex
-  def test_singleton_random_regex
-    patterns = ['\d\d\d',
-                '\w\w\w',
-                '[ABC][abc]',
-                '[012][345]',
-                '...',
-                '[a-z][0-9]',
-                '[aw-zX][123]',
-                '[a-z]{5}',
-                '0{80}',
-                '[a-f][nprt]\d{3}',
-                '\t\n\r\f\a\e',
-                '\S\S\S',
-                '\s\s\s',
-                '\w{5,10}',
-                '\w?',
-                '\w+',
-                '\w*',
-                '']
-
-    patterns.each do |pattern|
-      result = StringRandom.random_regex(pattern)
-      assert_match(/#{pattern}/, result, "#{result} is invalid: pattern #{pattern}")
-    end
-  end
-
-  # StringRandom.random_string
-  def test_singleton_random_string
-    assert_match(/\d/, StringRandom.random_string('n'))
-    assert_raise(RuntimeError) { StringRandom.random_string('0') }
-
-    # with optional lists
-    assert_equal('abc', StringRandom.random_string('012', ['a'], ['b'], ['c']))
-    assert_match(/[abc][def]/, StringRandom.random_string('01', ['a', 'b', 'c'], ['d', 'e', 'f']))
-  end
-end