shokkenki-support 0.0.3 → 0.0.4

data/lib/shokkenki/support/version.rb

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

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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,302 @@
+#
+# = 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

@@ -0,0 +1,180 @@
+#
+# 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shokkenki-support
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -113,6 +113,9 @@ 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
@@ -135,11 +138,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3238517007321891354
+      hash: -4075372475477493752
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: shokkenki-support-0.0.3
+summary: shokkenki-support-0.0.4
 test_files: []