cracell-randexp 0.1.2

data/CHANGELOG

@@ -0,0 +1,13 @@
+== 0.1.2 "I'm Not Saying It's Not Beta"
+* Changed rand to Kernel#rand to avoid conflicting with rails (thanks agile!)
+
+== 0.1.1 "Still Quite Beta" 2008-07-20
+* Added Range#of method.
+* Heavy refactoring of the Parser.parse method.
+* Fixed the /\./ bug.
+
+== 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.2"
+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, :package, :doc] 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.rb

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

data/lib/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def pick
+    at Kernel.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,9 @@
+class Range
+  def pick
+    to_a.pick
+  end
+
+  def of
+    pick.of { yield }
+  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/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.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/randexp/parser.rb

@@ -0,0 +1,97 @@
+class Randexp
+  class Parser
+    def self.parse(source)
+      case
+      when source =~ /^(.*)(\*|\*\?|\+|\+\?|\?)$/ && balanced?($1, $2)
+        parse_quantified($1, $2.to_sym)                                 # ends with *, +, or ?: /(..)?/
+      when source =~ /^(.*)\{(\d+)\,(\d+)\}$/ && balanced?($1, $2)
+        parse_quantified($1, ($2.to_i)..($3.to_i))                      #ends with a range: /(..){..,..}/
+      when source =~ /^(.*)\{(\d+)\}$/ && balanced?($1, $2)
+        parse_quantified($1, $2.to_i)                                   #ends with a range: /..(..){..}/
+      when source =~ /^\((.*)\)\((.*)\)$/ && balanced?($1, $2)
+        union(parse($1), parse($2))                                     #balanced union: /(..)(..)/
+      when source =~ /^(\(.*\))\|(\(.*\))$/ && balanced?($1, $2)
+        intersection(parse($1), parse($2))                              #balanced intersection: /(..)|(..)/
+      when source =~ /^(.*)\|(.*)$/ && balanced?($1, $2)
+        intersection(parse($1), parse($2))                              #implied intersection: /..|../
+      when source =~ /^(.*)\|\((\(.*\))\)$/ && balanced?($1, $2)
+        intersection(parse($1), parse($2))                              #unbalanced intersection: /(..)|((...))/
+      when source =~ /^(.+)(\(.*\))$/ && balanced?($1, $2)
+        union(parse($1), parse($2))                                     #unbalanced union: /...(...)/
+      when source =~ /^\((.*)\)$/ && balanced?($1)
+        union(parse($1))                                                #explicit group: /(..)/
+      when source =~ /^([^()]*)(\(.*\))$/ && balanced?($1, $2)
+        union(parse($1), parse($2))                                     #implied group: /..(..)/
+      when source =~ /^(.*)\[\:(.*)\:\]$/
+        union(parse($1), random($2))                                    #custom random: /[:word:]/
+      when source =~ /^(.*)\\([wsdc])$/
+        union(parse($1), random($2))                                    #reserved random: /..\w/
+      when source =~ /^(.*)\\(.)$/ || source =~ /(.*)(.|\s)$/
+        union(parse($1), literal($2))                                   #end with literal or space: /... /
+      else
+        nil
+      end
+    end
+
+    def self.parse_quantified(source, multiplicity)
+      case source
+      when /^[^()]*$/     then quantify_rhs(parse(source), multiplicity)    #implied union: /...+/
+      when /^(\(.*\))$/   then quantify(parse(source), multiplicity)        #group: /(...)?/
+      when /^(.*\))$/     then quantify_rhs(parse(source), multiplicity)    #implied union: /...(...)?/
+      when /^(.*[^)]+)$/  then quantify_rhs(parse(source), multiplicity)    #implied union: /...(...)...?/
+      else quantify(parse(source), multiplicity)
+      end
+    end
+
+    class << self
+      alias_method :[], :parse
+    end
+
+    def self.balanced?(*args)
+      args.all? {|s| s.count('(') == s.count(')')}
+    end
+
+    def self.quantify_rhs(sexp, multiplicity)
+      case sexp.first
+      when :union
+        rhs = sexp.pop
+        sexp << quantify(rhs, multiplicity)
+      else
+        quantify(sexp, multiplicity)
+      end
+    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/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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: cracell-randexp
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Ben Burkert
+autorequire: randexp
+bindir: bin
+cert_chain: []
+
+date: 2008-07-18 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Library for generating random strings.
+email: ben@benburkert.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- CHANGELOG
+- lib/core_ext
+- lib/core_ext/array.rb
+- lib/core_ext/integer.rb
+- lib/core_ext/range.rb
+- lib/core_ext/regexp.rb
+- lib/core_ext.rb
+- lib/dictionary.rb
+- lib/randexp
+- lib/randexp/parser.rb
+- lib/randexp/reducer.rb
+- lib/randexp.rb
+- lib/randgen.rb
+has_rdoc: true
+homepage: http://github.com/benburkert/randexp
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Library for generating random strings.
+test_files: []
+