randexp 0.1.0

data/CHANGELOG

@@ -0,0 +1,5 @@
+== 0.1.0 "Very Beta" 2008-07-08
+* Initial version of randexp!
+* Has support for very simple regular expressions.
+* Randgen has limited methods.
+* Dictionary is reading from the local words file.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ben Burkert
+
+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

@@ -0,0 +1,83 @@
+Randexp
+    by Ben Burkert
+    http://github.com/benburkert/randexp
+
+== DESCRIPTION:
+
+andexp makes it easy to generate random string from most regular expressions.
+
+== REQUIREMENTS:
+ 
+* none!
+ 
+== INSTALL:
+ 
+  $ gem sources -a http://gems.github.com/ (you only need to do this once)
+  $ gem install benburkert-randexp
+
+== USAGE:
+
+Randexp adds the #generate (or #gen, for short) method to the Regexp class,
+which generates a 'random' string that will match your regular expression.
+
+  /abc|def/.gen
+    # => "def"
+
+== Valid Regexp's
+
+Randexp can only generate matching string from simple regular expression.
+Except for a few circumstances, wildcards are generally not allowed in the
+regular expression.  is pretty domain specific, so trying to guess when to
+terminate a random pattern would produce unhelpful data:
+
+  >> /Aa{3}h*!/.gen
+      # => RuntimeError: Sorry, "h*" is too vague, try setting a range: "h{0,3}"
+  >> /Aa{3}h{3,15}!/.gen
+      => "Aaaahhhhh!"
+
+  >> /(never gonna (give you up|let you down), )*/.gen
+      => RuntimeError: Sorry, "(...)*" is too vague, try setting a range: "(...){0, 3}"
+  >> /(never gonna (give you up|let you down), ){3,5}/.gen
+      => "never gonna give you up, never gonna let you down, never gonna give you up, never gonna give you up, "
+
+The exception being word characters (\w), which generate a random word from the Dictionary class.
+
+  >> /\w+/.gen
+      => "groveling"
+
+= Primitives & Complex matches
+
+The single character matchers supported are words(\w), whitespace(\s), and digits(\d).
+
+  >> /\d{50}/.gen
+      => "50315410741096763188525493528315906035878741451037"
+
+When a multiplicity constraint is placed on a word character, a word with the valid length is generated.
+
+  >> /\w{10}/.gen  # a word with 10 letters
+      => "Chaucerism"
+
+  >> /\w{5,15}/.gen
+      => "cabalistic"
+
+Complex matchers use the [:...:] syntax within the regular expression.
+
+  >> /[:sentence:]/.gen
+      => "Nonhearer demetricize toppiece filicic possessedness rhodizite zoomagnetism earwigginess steady"
+
+Complex matchers can also be added by extending the Randgen class.
+
+  class Randgen
+    def self.serial_number(options = {})
+      /XX\d{4}-\w-\d{5}/.gen
+    end
+  end
+
+  >> /[:serial_number:]/.gen
+      => "XX3770-M-33114"
+
+= Dictionary
+
+The Dictionary loads the local users' words file, allowing randomly generated words to be chosen from
+thousands of entries to the words file.  Words are mapped by their length to allow words to be randomly
+chosen based on size.

data/Rakefile

@@ -0,0 +1,111 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require "spec/rake/spectask"
+require 'rake/rdoctask'
+
+PROJECT_NAME = "randexp"
+GEM = "randexp"
+GEM_VERSION = "0.1.0"
+AUTHOR = "Ben Burkert"
+EMAIL = "ben@benburkert.com"
+HOMEPAGE = "http://github.com/benburkert/randexp"
+TITLE = "Randexp Gem"
+SUMMARY = "Library for generating random strings."
+FILES = %w(LICENSE README README Rakefile TODO CHANGELOG) + Dir.glob("{lib,spec}/**/*")
+RDOC_FILES = %w(LICENSE README README Rakefile TODO CHANGELOG) + Dir.glob("lib/**/*")
+
+RUBYFORGE_USER = "benburkert"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = FILES
+end
+
+Rake::GemPackageTask.new(spec) do |package|
+  package.gem_spec = spec
+  package.need_zip = true
+  package.need_tar = true
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+##############################################################################
+# rSpec & rcov
+##############################################################################
+desc "Run all unit specs"
+Spec::Rake::SpecTask.new("specs:unit") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/unit/**/*_spec.rb"].sort
+  t.rcov = true
+  t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  t.rcov_opts << '--only-uncovered'
+  t.rcov_opts << '--output coverage/unit'
+  
+end
+
+desc "Run all regression specs"
+Spec::Rake::SpecTask.new("specs:regression") do |t|
+  t.spec_opts = ["--format", "specdoc", "--colour"]
+  t.spec_files = Dir["spec/regression/**/*_spec.rb"].sort
+  t.rcov = true
+  t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+  t.rcov_opts << '--only-uncovered'
+  t.rcov_opts << '--output coverage/integration'
+end
+
+task :specs => ['specs:unit', 'specs:regression']
+
+##############################################################################
+# Documentation
+##############################################################################
+task :doc => "doc:rerdoc"
+namespace :doc do
+
+  Rake::RDocTask.new do |rdoc|
+    rdoc.rdoc_files.add(RDOC_FILES)
+    rdoc.main = 'README'
+    rdoc.title = TITLE
+    rdoc.rdoc_dir = "rdoc"
+    rdoc.options << '--line-numbers' << '--inline-source'
+  end
+
+  desc "rdoc to rubyforge"
+  task :rubyforge => :doc do
+    sh %{chmod -R 755 rdoc}
+    sh %{/usr/bin/scp -r -p rdoc/* #{RUBYFORGE_USER}@rubyforge.org:/var/www/gforge-projects/#{PROJECT_NAME}/#{GEM}}
+  end
+end
+
+##############################################################################
+# release
+##############################################################################
+task :release => [:specs, "doc:rubyforge", :package] do
+  sh %{rubyforge add_release #{PROJECT_NAME} #{GEM} "#{GEM_VERSION}" pkg/#{GEM}-#{GEM_VERSION}.gem}
+  %w[zip tgz].each do |ext|
+    sh %{rubyforge add_file #{PROJECT_NAME} #{GEM} "#{GEM_VERSION}" pkg/#{GEM}-#{GEM_VERSION}.#{ext}}
+  end
+end

data/TODO

@@ -0,0 +1,5 @@
+== Todo list
+* add a ~/.randexp dir for configuration
+* clean up Randexp::Parser.parse
+* add [] syntax: /[aeiou]{4}/.gen
+* more generators for Randgen

data/lib/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def pick
+    at rand(size)
+  end
+end

data/lib/core_ext/integer.rb

@@ -0,0 +1,5 @@
+class Integer
+  def of
+    (1..self).to_a.map { yield }
+  end
+end

data/lib/core_ext/range.rb

@@ -0,0 +1,5 @@
+class Range
+  def pick
+    to_a.pick
+  end
+end

data/lib/core_ext/regexp.rb

@@ -0,0 +1,7 @@
+class Regexp
+  def generate
+    Randexp.new(source).reduce
+  end
+
+  alias_method :gen, :generate
+end

data/lib/core_ext.rb

@@ -0,0 +1,4 @@
+require 'core_ext/array'
+require 'core_ext/integer'
+require 'core_ext/range'
+require 'core_ext/regexp'

data/lib/dictionary.rb

@@ -0,0 +1,24 @@
+class Dictionary
+  def self.load_dictionary
+    if File.exists?("/usr/share/dict/words")
+      File.read("/usr/share/dict/words").split
+    elsif File.exists?("/usr/dict/words")
+      File.read("/usr/dict/words").split
+    else
+      raise "words file not found"
+    end
+  end
+
+  def self.words(options = {})
+    case
+    when options.has_key?(:length)
+      words_by_length[options[:length]]
+    else
+      @@words ||= load_dictionary
+    end
+  end
+
+  def self.words_by_length
+    @@words_by_length ||= words.inject({}) {|h, w| (h[w.size] ||= []) << w; h }
+  end
+end

data/lib/randexp/parser.rb

@@ -0,0 +1,72 @@
+class Randexp
+  class Parser
+    def self.parse(source)
+      case source
+      when /^\(([^()]*|\(.*\))\)$/                  then union(parse($1))
+      when /(.*)\|(?:(\({2,}.*\){2,}|[^()]*))$/     then intersection(parse($1), parse($2))
+      when /(.*)\|(\(.*\))$/                        then intersection(parse($1), parse($2))
+      when /(.*)\(([^()]*)\)(\*|\*\?|\+|\+\?|\?)$/  then union(parse($1), quantify(parse($2), $3.to_sym))
+      when /(.*)\(([^()]*)\)\{(\d+)\,(\d+)\}$/      then union(parse($1), quantify(parse($2), ($3.to_i)..($4.to_i)))
+      when /(.*)\(([^()]*)\)\{(\d+)\}$/             then union(parse($1), quantify(parse($2), $3.to_i))
+      when /(.*)\(([^()]*)\)$/                      then union(parse($1), parse($2))
+      when /(.*)\[:(\w+):\](\*|\*\?|\+|\+\?|\?)$/   then union(parse($1), quantify(random($2), $3.to_sym))
+      when /(.*)\[:(\w+):\]\{(\d+)\,(\d+)\}$/       then union(parse($1), quantify(random($2), ($3.to_i)..($4.to_i)))
+      when /(.*)\[:(\w+):\]\{(\d+)\}$/              then union(parse($1), quantify(random($2), $3.to_i))
+      when /(.*)\[:(\w+):\]$/                       then union(parse($1), random($2))
+      when /(.*)\\([wsdc])(\*|\*\?|\+|\+\?|\?)$/    then union(parse($1), quantify(random($2), $3.to_sym))
+      when /(.*)\\([wsdc])\{(\d+)\,(\d+)\}$/        then union(parse($1), quantify(random($2), ($3.to_i)..($4.to_i)))
+      when /(.*)\\([wsdc])\{(\d+)\}$/               then union(parse($1), quantify(random($2), $3.to_i))
+      when /(.*)\\([wsdc])$/                        then union(parse($1), random($2))
+      when /\((.*)\)(\*|\*\?|\+|\+\?|\?)$/          then quantify(parse($1), $2.to_sym)
+      when /\((.*)\)\{(\d+)\,(\d+)\}$/              then quantify(parse($1), ($2.to_i)..($3.to_i))
+      when /\((.*)\)\{(\d+)\}$/                     then quantify(parse($1), $3.to_i)
+      when /(.*)(.|\s)(\*|\*\?|\+|\+\?|\?)$/        then union(parse($1), quantify(literal($2), $3.to_sym))
+      when /(.*)(.|\s)\{(\d+)\,(\d+)\}$/            then union(parse($1), quantify(literal($2), ($3.to_i)..($4.to_i)))
+      when /(.*)(.|\s)\{(\d+)\}$/                   then union(parse($1), quantify(literal($2), $3.to_i))
+      when /(.*)\\([.\/])(\*|\*\?|\+|\+\?|\?)$/     then union(parse($1), quantify(literal($2), $3.to_sym))
+      when /(.*)\\([.\/])\{(\d+)\,(\d+)\}$/         then union(parse($1), quantify(literal($2), ($3.to_i)..($4.to_i)))
+      when /(.*)\\([.\/])\{(\d+)\}$/                then union(parse($1), quantify(literal($2), $3.to_i))
+      when /(.*)\\([.\/])$/                         then union(parse($1), literal($2))
+      when /(.*)(.|\s)$/                            then union(parse($1), literal($2))
+      else nil
+      end
+    end
+
+    class << self
+      alias_method :[], :parse
+    end
+
+    def self.quantify(lhs, sym)
+      [:quantify, lhs, sym]
+    end
+
+    def self.union(lhs, *rhs)
+      if lhs.nil?
+        union(*rhs)
+      elsif rhs.empty?
+        lhs
+      elsif lhs.first == :union
+        rhs.each {|s| lhs << s}
+        lhs
+      else
+        [:union, lhs, *rhs]
+      end
+    end
+
+    def self.intersection(lhs, rhs)
+      if rhs.first == :intersection
+        [:intersection, lhs] + rhs[1..-1]
+      else
+        [:intersection, lhs, rhs]
+      end
+    end
+
+    def self.random(char)
+      [:random, char.to_sym]
+    end
+
+    def self.literal(word)
+      [:literal, word]
+    end
+  end
+end

data/lib/randexp/reducer.rb

@@ -0,0 +1,102 @@
+class Randexp
+  class Reducer
+    def self.reduce(sexp, quantity = nil)
+      send(sexp.first, sexp[1..-1], quantity)
+    end
+
+    class << self
+      alias_method :[], :reduce
+    end
+
+    def self.quantify(sexp, old_quantity)
+      reduce(*sexp)
+    end
+
+    def self.random(sexpish, quantity)
+      case s = sexpish.first
+      when :w then char(quantity)
+      when :s then whitespace(quantity)
+      when :d then digit(quantity)
+      else randgen(s, quantity)
+      end
+    end
+
+    def self.literal(cell, quantity = nil)
+      case quantity
+      when :'?'         then ([''] + cell).pick * ''
+      when :+, :'+?'    then raise "Sorry, \"#{cell * ''}+\" is too vague, try setting a range: \"#{cell * ''}{1,3}\""
+      when :*, :'*?'    then raise "Sorry, \"#{cell * ''}*\" is too vague, try setting a range: \"#{cell * ''}{0,3}\""
+      when Range        then quantity.pick.of { cell * '' } * ''
+      when Integer      then quantity.of { cell * '' } * ''
+      when nil          then cell * ''
+      end
+    end
+
+    def self.intersection(cell, quantity)
+      case quantity
+      when :'?'       then ['', cell.map {|s| reduce(s)}.pick].pick
+      when :+, :'+?'  then raise "Sorry, \"((...)|(...))+\" is too vague, try setting a range: \"((...)|(...)){1, 3}\""
+      when :*, :'*?'  then raise "Sorry, \"((...)|(...))*\" is too vague, try setting a range: \"((...)|(...)){0, 3}\""
+      when Range      then quantity.pick.of { cell.map {|s| reduce(s)}.pick } * ''
+      when Integer    then quantity.of { cell.map {|s| reduce(s)}.pick } * ''
+      when nil        then cell.map {|s| reduce(s)}.pick
+      end
+    end
+
+    def self.union(cell, quantity)
+      case quantity
+      when :'?'       then ['', cell.map {|s| reduce(s)} * ''].pick
+      when :+, :'+?'  then raise "Sorry, \"(...)+\" is too vague, try setting a range: \"(...){1, 3}\""
+      when :*, :'*?'  then raise "Sorry, \"(...)*\" is too vague, try setting a range: \"(...){0, 3}\""
+      when Range      then quantity.pick.of { cell.map {|s| reduce(s)} * '' } * ''
+      when Integer    then quantity.of { cell.map {|s| reduce(s)} * '' } * ''
+      when nil        then cell.map {|s| reduce(s)} * ''
+      end
+    end
+
+    def self.char(quantity)
+      case quantity
+      when :'?'       then ['', Randgen.char].pick
+      when :+, :'+?'  then Randgen.word
+      when :*, :'*?'  then ['', Randgen.word].pick
+      when Range      then Randgen.word(:length => quantity.pick)
+      when 1, nil     then Randgen.char
+      when Integer    then Randgen.word(:length => quantity)
+      end
+    end
+
+    def self.whitespace(quantity)
+      case quantity
+      when :'?'       then ['', Randgen.whitespace].pick
+      when :+, :'+?'  then raise "Sorry, \"\\s+\" is too vague, try setting a range: \"\\s{1, 5}\""
+      when :*, :'*?'  then raise "Sorry, \"\\s*\" is too vague, try setting a range: \"\\s{0, 5}\""
+      when Range      then quantity.pick.of { Randgen.whitespace } * ''
+      when Integer    then quantity.of { Randgen.whitespace } * ''
+      when nil        then Randgen.whitespace
+      end
+    end
+
+    def self.digit(quantity)
+      case quantity
+      when :'?'       then ['', Randgen.digit].pick
+      when :+, :'+?'  then raise "Sorry, \"\\d+\" is too vague, try setting a range: \"\\d{1, 5}\""
+      when :*, :'*?'  then raise "Sorry, \"\\d*\" is too vague, try setting a range: \"\\d{0, 5}\""
+      when Range      then quantity.pick.of { Randgen.digit } * ''
+      when Integer    then quantity.of { Randgen.digit } * ''
+      when nil        then Randgen.digit
+      end
+    end
+
+    def self.randgen(args, quantity)
+      method_name = *args
+      case quantity
+      when :'?'       then ['', Randgen.send(method_name, :length => 1)].pick
+      when :+, :'+?'  then Randgen.send(method_name)
+      when :*, :'*?'  then ['', Randgen.send(method_name)].pick
+      when Range      then Randgen.send(method_name, :length => quantity.pick)
+      when 1, nil     then Randgen.send(method_name)
+      when Integer    then Randgen.send(method_name, :length => quantity)
+      end
+    end
+  end
+end

data/lib/randexp.rb

@@ -0,0 +1,17 @@
+class Randexp
+  attr_accessor :sexp
+
+  def initialize(source)
+    @sexp = Randexp::Parser[source]
+  end
+
+  def reduce
+    Reducer[@sexp.dup]
+  end
+end
+
+require 'core_ext'
+require 'randexp/parser'
+require 'randexp/reducer'
+require 'randgen'
+require 'dictionary'

data/lib/randgen.rb

@@ -0,0 +1,52 @@
+class Randgen
+  WORDS_PER_SENTENCE = 3..20
+  SENTENCES_PER_PARAGRAPH = 3..8
+  
+  def self.bool(options = {})
+    ['true', 'false'].pick
+  end
+
+  def self.lchar(options = {})
+    ('a'..'z').to_a.pick
+  end
+
+  def self.uchar(options = {})
+    ('A'..'Z').to_a.pick
+  end
+
+  def self.char(options = {})
+    [lchar, uchar].pick
+  end
+
+  def self.whitespace(options = {})
+    ["\t", "\n", "\r", "\f"].pick
+  end
+
+  def self.digit(options = {})
+    ('0'..'9').to_a.pick
+  end
+
+  def self.alpha_numeric(options = {})
+    [char, digit].pick
+  end
+
+  def self.word(options = {})
+    Dictionary.words(options).pick
+  end
+
+  def self.sentence(options = {})
+    ((options[:length] || WORDS_PER_SENTENCE.pick).of { word } * " ").capitalize
+  end
+
+  def self.paragraph(options = {})
+    ((options[:length] || SENTENCES_PER_PARAGRAPH.pick).of { sentence } * ".  ") + "."
+  end
+
+  def self.phone_number(options = {})    
+    case options[:length]
+    when 7  then  /\d{3}-\d{4}/.gen
+    when 10 then  /\d{3}-\d{3}-\d{4}/.gen
+    else          /(\d{3}-)?\d{3}-\d{4}/.gen
+    end
+  end
+end

data/spec/regression/regexp_spec.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "#{'*' * 80}\nRegression Specs:" do
+  it "/abcd/                          => 'abcd'" do
+    100.times do
+      /abcd/.gen.should == 'abcd'
+    end
+  end
+
+  it "/(abcd)|(defg)/                 => ['abcd', 'defg']" do
+    100.times do
+      ['abcd', 'defg'].should include(/(abcd)|(defg)/.gen)
+    end
+  end
+
+  it "/(abcd)|(defg)|(hijk)/          => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/(abcd)|(defg)|(hijk)/.gen)
+    end
+  end
+
+  it "/((abcd)|(defg))|(hijk)/        => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/((abcd)|(defg))|(hijk)/.gen)
+    end
+  end
+
+  it "/(abcd)|((defg)|(hijk))/        => ['abcd', 'defg', 'hijk']" do
+    100.times do
+      ['abcd', 'defg', 'hijk'].should include(/(abcd)|((defg)|(hijk))/.gen)
+    end
+  end
+
+  it "/(abc)def(ghi)/                 => 'abcdefghi'" do
+    100.times do
+      /(abc)def(ghi)/.gen.should == 'abcdefghi'
+    end
+  end
+
+  it "/(((abc)))/                     => 'abc'" do
+    100.times do
+      /(((abc)))/.gen.should == 'abc'
+    end
+  end
+
+  it "/(\\w+)/                         => /\\w+/" do
+    100.times do
+      /(\w+)/.gen.should =~ /\w+/
+    end
+  end
+
+  it "/\\w+ \\w+/                       => /\\w+\\s\\w+/" do
+    100.times do
+      /\w+ \w+/.gen.should =~ /\w+\s\w+/
+    end
+  end
+
+  it "/\\w*/                           => /(\\w+)|/" do
+    100.times do
+      /\w*/.gen.should =~ /(\w+)|/
+    end
+  end
+
+  it "/\\w{2,5}/                       => /\\w{2,5}/" do
+    100.times do
+      /\w{2,5}/.gen.should =~ /\w{2,5}/
+    end
+  end
+
+  it "/\\w{1}/                         => /\\w/" do
+    100.times do
+      /\w{1}/.gen.should =~ /\w/
+    end
+  end
+
+  it "/\\w{4}/                         => /\\w{4}/" do
+    100.times do
+      /\w{4}/.gen.should =~ /\w{4}/
+    end
+  end
+
+  it "/[:word:]/                      => /\\w+/" do
+    100.times do
+      /[:word:]/.gen.should =~ /\w+/
+    end
+  end
+
+  it "/[:bool:]/                      => /true|false/" do
+    /[:bool:]/.gen.should =~ /true|false/
+  end
+
+  it "/[:sentence:]/                  => /(\w+ )*/" do
+    100.times do
+      /[:sentence:]/.gen.should =~ /(\w+ )*/
+    end
+  end
+
+  it "/[:paragraph:]/                 => /(  (\w+ )*\.)*/" do
+    100.times do
+      /[:paragraph:]/.gen.should =~ /(\w+ )*/
+    end
+  end
+
+  it "/(abc|def){1,2}/                => ['abc', 'def', 'abcabc', 'abcdef', 'defabc', 'defdef']" do
+    100.times do
+      ['abc', 'def', 'abcabc', 'abcdef', 'defabc', 'defdef'].should include(/(abc|def){1,2}/.gen)
+    end
+  end
+
+  it "/(\\d{3}-)?\\d{3}-\\d{4}/          => /(\\d{3}-)?\\d{3}-\\d{4}/" do
+    100.times do
+      /(\d{3}-)?\d{3}-\d{4}/.gen.should =~ /(\d{3}-)?\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]/              => /(\\d{3}-)?\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]/.gen.should =~ /(\d{3}-)?\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]{7}/           => /\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]{7}/.gen.should =~ /\d{3}-\d{4}/
+    end
+  end
+
+  it "/[:phone_number:]{10}/          => /\\d{3}-\\d{3}-\\d{4}/" do
+    100.times do
+      /[:phone_number:]{10}/.gen.should =~ /\d{3}-\d{3}-\d{4}/
+    end
+  end
+
+  it "/\\w+@\\w+\\.(com|org|net)/     => /\\w+@\\w+\\.(com|org|net)/.gen" do
+    100.times do
+      /\w+@\w+\.(com|org|net)/.gen.should =~ /\w+@\w+\.(com|org|net)/
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'spec'
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require 'randexp'
+
+Spec::Runner.configure do |config|
+end