expgen 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in expgen.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jonas Nicklas
+
+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,42 @@
+# Expgen
+
+Expgen solves a very simple problem: Given a regular expression, find a string
+which matches that regular expression. Use it like this:
+
+``` ruby
+Expgen.gen(/foo\w+b[a-z]{2,3}/) # => "fooxbdp"
+```
+
+For a full list of supported syntax, see the spec file.
+
+Some things are really difficult to generate accurate expressions for, it's
+even quite easy to create a regexp which matches *no* strings. For example
+`/a\bc/` will not match any string, since there can never be a word boundary
+between characters.
+
+When given a negative character class, Expgen takes the entire ASCII character
+set (sans control characters) and removes from it any characters excluded by the
+character class. In other words, if the character class excludes the *entire*
+ASCII character set, Expgen will be unable to fill this space.
+
+The following is a list of things Expgen does *not* support:
+
+- Anchors (are ignored)
+- Lookaheads and lookbehinds
+- Subexpressions
+- Backreferences
+
+## Doesn't this already exist?
+
+There is a gem called Randexp which does much the same thing. Expgen differs
+from Randexp in two important ways. (1) It actually works. (2) It supports a
+*much* wider range of regexp syntax.
+
+The idea behind Expgen is that you should be able to take any reasonable, real
+world regular expression and be able to generate matching strings. The focus is
+on finding Strings which match a particular expression, not necessarily using
+it as a random generator.
+
+# License
+
+MIT, see separate LICENSE.txt file

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/expgen

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "expgen"
+puts Expgen.gen(ARGV.first)

data/expgen.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'expgen/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "expgen"
+  gem.version       = Expgen::VERSION
+  gem.authors       = ["Jonas Nicklas"]
+  gem.email         = ["jonas.nicklas@gmail.com"]
+  gem.description   = %q{Generate random strings from regular expression}
+  gem.summary       = %q{Generate random regular expression}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency "parslet"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "rspec"
+end

data/lib/expgen.rb

@@ -0,0 +1,43 @@
+require "parslet"
+require "expgen/version"
+require "expgen/parser"
+require "expgen/transform"
+require "expgen/randomizer"
+require "expgen/nodes"
+
+module Expgen
+  ASCII = (32..126).map(&:chr)
+  LOWER = ("a".."z").to_a
+  UPPER = ("A".."Z").to_a
+  DIGIT = (0..9).map(&:to_s)
+  ALPHA = LOWER + UPPER
+  WORD = ALPHA + DIGIT + ["_"]
+  NEGATIVE_WORD = ASCII - WORD
+  NON_DIGIT = ASCII - DIGIT
+  HEX_DIGIT = ("a".."f").to_a + ("A".."F").to_a + DIGIT
+  NON_HEX_DIGIT = ASCII - HEX_DIGIT
+  SPACE = [" "]
+  NON_SPACE = ASCII.drop(1)
+  CONTROL_CHARS = (0.chr..31.chr).to_a
+  PUNCT = (33..47).map(&:chr) + (58..64).map(&:chr) + (91..96).map(&:chr) + (123..126).map(&:chr)
+
+  ESCAPE_CHARS = { "n" => "\n", "s" => "\s", "r" => "\r", "t" => "\t", "v" => "\v", "f" => "\f", "a" => "\a", "e" => "\e" }
+
+  class ParseError < StandardError; end
+
+  def self.cache
+    @cache ||= {}
+  end
+
+  def self.clear_cache
+    @cache = nil
+  end
+
+  def self.gen(exp)
+    source = if exp.respond_to?(:source) then exp.source else exp.to_s end
+    cache[source] ||= Transform.new.apply((Parser::Expression.new.parse(source)))
+    Randomizer.randomize(cache[source])
+  rescue Parslet::ParseFailed => e
+    raise Expgen::ParseError, e.message
+  end
+end

data/lib/expgen/nodes.rb

@@ -0,0 +1,128 @@
+module Expgen
+  module Nodes
+    class Node
+      attr_reader :ast
+
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def repeat
+        ast[:repeat]
+      end
+    end
+
+    class Group < Node
+      def elements
+        ast[:elements]
+      end
+    end
+
+    class Alternation < Node
+      def options
+        ast.map { |option| option[:alt] }
+      end
+    end
+
+    class Character < Node; end
+
+    class CharacterClass < Character
+      def groups
+        ast[:groups]
+      end
+
+      def chars
+        chars = groups.map(&:chars).flatten
+        val = if ast[:negative]
+          ASCII - chars
+        else
+          chars
+        end
+      end
+    end
+
+    class Literal < Character
+      def chars
+        [ast[:letter].to_s]
+      end
+    end
+
+    class Wildcard < Character
+      def chars
+        ASCII
+      end
+    end
+
+    class Shorthand < Character
+      def chars
+        case ast[:letter].to_s
+          when "w" then WORD
+          when "W" then NEGATIVE_WORD
+          when "d" then DIGIT
+          when "D" then NON_DIGIT
+          when "h" then HEX_DIGIT
+          when "H" then NON_HEX_DIGIT
+          when "s" then SPACE
+          when "S" then NON_SPACE
+        end
+      end
+    end
+
+    class BracketExpression < Character
+      def chars
+        case ast[:name].to_s
+          when "alnum" then ALPHA + DIGIT
+          when "alpha" then ALPHA
+          when "blank" then " "
+          when "cntrl" then CONTROL_CHARS
+          when "digit" then DIGIT
+          when "graph" then NON_SPACE
+          when "lower" then LOWER
+          when "print" then ASCII
+          when "punct" then PUNCT
+          when "space" then SPACE
+          when "upper" then UPPER
+          when "xdigit" then HEX_DIGIT
+          when "word" then WORD + ["_"]
+          when "ascii" then ASCII
+        end
+      end
+    end
+
+    class Range < Character
+      def chars
+        (ast[:from].to_s..ast[:to].to_s).to_a
+      end
+    end
+
+    class EscapeCharControl < Character
+      def chars
+        [ESCAPE_CHARS[ast[:letter].to_s]]
+      end
+    end
+
+    class EscapeCharLiteral < Character
+      def chars
+        [ast[:letter].to_s]
+      end
+    end
+
+    class CodePointOctal < Character
+      def chars
+        [ast[:code].to_s.to_i(8).chr]
+      end
+    end
+
+    class CodePointHex < Character
+      def chars
+        [ast[:code].to_s.to_i(16).chr]
+      end
+    end
+
+    class CodePointUnicode < Character
+      def chars
+        [ast[:code].to_s.to_i(16).chr("UTF-8")]
+      end
+    end
+  end
+end

data/lib/expgen/parser.rb

@@ -0,0 +1,85 @@
+module Expgen
+  NON_LITERALS = "[]\^$.|?*+()".split("").map { |l| "\\" + l }.join
+
+  module Parser
+    class Repeat < Parslet::Parser
+      rule(:lcurly)     { str('{') }
+      rule(:rcurly)     { str('}') }
+      rule(:multiply)   { str('*') }
+      rule(:plus)       { str('+') }
+      rule(:comma)      { str(',') }
+      rule(:questionmark) { str('?') }
+
+      rule(:integer) { match('[0-9]').repeat(1).as(:int) }
+
+      rule(:amount) { lcurly >> integer.as(:repeat) >> (comma >> integer.as(:max).maybe).maybe >> rcurly }
+      rule(:repeat) { plus.as(:repeat) | multiply.as(:repeat) | questionmark.as(:optional) | amount }
+
+      root(:repeat)
+    end
+
+    class EscapeChar < Parslet::Parser
+      rule(:backslash)  { str('\\') }
+
+      rule(:code_point_octal) { backslash >> match["0-7"].repeat(3,3).as(:code) >> Repeat.new.maybe }
+      rule(:code_point_hex) { backslash >> str("x") >> match["0-9a-fA-F"].repeat(2,2).as(:code) >> Repeat.new.maybe }
+      rule(:code_point_unicode) { backslash >> str("u") >> match["0-9a-fA-F"].repeat(4,4).as(:code) >> Repeat.new.maybe }
+      rule(:escape_char_control) { backslash >> match["nsrtvfae"].as(:letter) >> Repeat.new.maybe }
+      rule(:escape_char_literal) { backslash >> any.as(:letter) >> Repeat.new.maybe }
+
+      rule(:escape_char) { escape_char_control.as(:escape_char_control) | code_point_octal.as(:code_point_octal) | code_point_hex.as(:code_point_hex) | code_point_unicode.as(:code_point_unicode) | escape_char_literal.as(:escape_char_literal) }
+      root(:escape_char)
+    end
+
+    class ShorthandCharacterClass < Parslet::Parser
+      rule(:backslash)  { str('\\') }
+
+      rule(:char_class_shorthand) { (backslash >> match["wWdDhHsS"].as(:letter) >> Repeat.new.maybe).as(:char_class_shorthand) }
+
+      root(:char_class_shorthand)
+    end
+
+    class CharacterClass < Parslet::Parser
+      rule(:dash)       { str('-') }
+      rule(:lbracket)   { str('[') }
+      rule(:rbracket)   { str(']') }
+
+      rule(:alpha) { match["a-z"] }
+      rule(:number) { match["0-9"] }
+      rule(:char) { match["^\\[\\]"].as(:letter) }
+      rule(:wildcard) { str('.').as(:wildcard) }
+      rule(:range) { (alpha.as(:from) >> dash >> alpha.as(:to)) | (number.as(:from) >> dash >> number.as(:to)) }
+      rule(:bracket_expression) { str("[:") >> alpha.repeat(1).as(:name) >> str(":]") }
+
+      rule(:contents) { ShorthandCharacterClass.new | EscapeChar.new | range.as(:char_class_range) | char.as(:char_class_literal) | bracket_expression.as(:bracket_expression) }
+      rule(:negative) { match["\\^"] }
+
+      rule(:char_class) { (lbracket >> negative.maybe.as(:negative) >> contents.repeat.as(:groups) >> rbracket >> Repeat.new.maybe).as(:char_class) }
+      root(:char_class)
+    end
+
+    class Expression < Parslet::Parser
+      rule(:lparen)     { str('(') }
+      rule(:rparen)     { str(')') }
+      rule(:pipe)       { str('|') }
+      rule(:backslash)  { str('\\') }
+
+      rule(:literal) { match["^#{NON_LITERALS}"].as(:letter) >> Repeat.new.maybe  }
+
+      rule(:wildcard) { str('.').as(:wildcard) >> Repeat.new.maybe }
+
+      rule(:non_capturing) { str('?:') | str("?-mix:") }
+      rule(:group) { lparen >> non_capturing.maybe >> expression.as(:elements) >> rparen >> Repeat.new.maybe }
+
+      rule(:thing) { anchor | ShorthandCharacterClass.new | EscapeChar.new | wildcard.as(:wildcard) | literal.as(:literal) | group.as(:group) | CharacterClass.new }
+      rule(:things) { thing.repeat(1) }
+
+      rule(:anchor) { str("^") | str("$") | backslash >> match["bBAzZ"] }
+
+      rule(:alternation) { things.as(:alt) >> (pipe >> things.as(:alt)).repeat(1) }
+
+      rule(:expression) { alternation.as(:alternation) | things }
+      root(:expression)
+    end
+  end
+end

data/lib/expgen/randomizer.rb

@@ -0,0 +1,32 @@
+module Expgen
+  module Randomizer
+    extend self
+
+    def range(number)
+      if number == "*"
+        [0,5]
+      elsif number == "+"
+        [1,5]
+      elsif number
+        [number[:int].to_i, number[:int].to_i]
+      else
+        [1,1]
+      end
+    end
+
+    def repeat(number)
+      first, last = range(number)
+      number = rand(last - first + 1) + first
+      number.times.map { yield }.join
+    end
+
+    def randomize(tree)
+      case tree
+        when Array              then tree.map { |el| randomize(el) }.join
+        when Nodes::Alternation then randomize(tree.options.sample)
+        when Nodes::Group       then repeat(tree.repeat) { randomize(tree.elements) }
+        when Nodes::Character   then repeat(tree.repeat) { tree.chars.sample }
+      end
+    end
+  end
+end

data/lib/expgen/transform.rb

@@ -0,0 +1,18 @@
+module Expgen
+  class Transform < Parslet::Transform
+    rule(:literal => subtree(:x)) { Nodes::Literal.new(x) }
+    rule(:wildcard => subtree(:x)) { Nodes::Wildcard.new(x) }
+    rule(:char_class_range => subtree(:x)) { Nodes::Range.new(x) }
+    rule(:char_class_literal => subtree(:x)) { Nodes::Literal.new(x) }
+    rule(:char_class_shorthand => subtree(:x)) { Nodes::Shorthand.new(x) }
+    rule(:char_class => subtree(:x)) { Nodes::CharacterClass.new(x) }
+    rule(:escape_char_control => subtree(:x)) { Nodes::EscapeCharControl.new(x) }
+    rule(:escape_char_literal => subtree(:x)) { Nodes::EscapeCharLiteral.new(x) }
+    rule(:code_point_octal => subtree(:x)) { Nodes::CodePointOctal.new(x) }
+    rule(:code_point_hex => subtree(:x)) { Nodes::CodePointHex.new(x) }
+    rule(:code_point_unicode => subtree(:x)) { Nodes::CodePointUnicode.new(x) }
+    rule(:bracket_expression => subtree(:x)) { Nodes::BracketExpression.new(x) }
+    rule(:group => subtree(:x)) { Nodes::Group.new(x) }
+    rule(:alternation => subtree(:x)) { Nodes::Alternation.new(x) }
+  end
+end

data/lib/expgen/version.rb

@@ -0,0 +1,3 @@
+module Expgen
+  VERSION = "0.1.0"
+end

data/spec/expgen_spec.rb

@@ -0,0 +1,243 @@
+require "spec_helper"
+
+describe Expgen do
+  def self.test(exp)
+    it "can generate expressions which match #{exp.inspect}", :caller => caller do
+      20.times { Expgen.gen(exp).should =~ exp }
+    end
+  end
+
+  it "raises an exception if the regexp can't be parsed" do
+    expect { Expgen.gen(/(?!foo)/) } .to raise_error(Expgen::ParseError)
+  end
+
+  it "can generate from a string" do
+    Expgen.gen("f\wo").should =~ /f\wo/
+  end
+
+  test(/foo|bar/)
+
+  describe "groups" do
+    test(/(foo)/)
+    test(/(foo|bar)/)
+    test(/f(oo|ba)r/)
+    test(/f(oo|ba){3}r/)
+    test(/f(oo|ba){3,6}r/)
+    test(/f(oo|ba){3,}r/)
+    test(/f(oo|ba)+r/)
+    test(/f(oo|ba)*r/)
+    test(/f(oo|ba)?r/)
+    test(/f(oo|ba|qx|foo)+r/)
+    test(/(oo)|(ba)/)
+    test(/(o(blah|baz)(o|b))|(ba)/)
+  end
+
+  describe "character classes" do
+    test(/[abcd]/)
+    test(/f[abcd]b/)
+    test(/f[a-z]b/)
+    test(/f[0-9]b/)
+    test(/f[&a-z%]b/)
+    test(/f[abcd]b/)
+    test(/f[abcd]*b/)
+    test(/f[abcd]+b/)
+    test(/f[abcd]{2}b/)
+    test(/f[abcd]{2,}b/)
+    test(/f[abcd]{2,4}b/)
+    test(/f[abcd]?b/)
+  end
+
+  describe "anchors (are simply ignored)" do
+    test(/^foo$/)
+    test(/\bfoo\b/)
+    test(/f\Bfo/)
+    test(/\Afoo\z/)
+    test(/\Afoo\Z/)
+  end
+
+  describe "shorthand character classes" do
+    test(/f\wo/)
+    test(/f\w+o/)
+    test(/f\w*o/)
+    test(/f\w{2}o/)
+    test(/f\w{3,}o/)
+    test(/f\w{2,4}o/)
+    test(/f\w?o/)
+    test(/f\Wo/)
+    test(/f\do/)
+    test(/f\Do/)
+    test(/f\ho/)
+    test(/f\Ho/)
+    test(/f\so/)
+    test(/f\So/)
+  end
+
+  describe "shorthand character classes inside regular character classes" do
+    test(/f[\w]o/)
+    test(/f[\w%&]o/)
+    test(/f[\w]o/)
+  end
+
+  describe "negated character classes" do
+    test(/[^abcd]/)
+    test(/f[^abcd]b/)
+    test(/f[^a-z]b/)
+    test(/f[^0-9]b/)
+    test(/f[^&a-z%]b/)
+    test(/f[^abcd]b/)
+    test(/f[^abcd]*b/)
+    test(/f[^abcd]+b/)
+    test(/f[^abcd]{2}b/)
+    test(/f[^abcd]{2,}b/)
+    test(/f[^abcd]{2,4}b/)
+    test(/f[^\w]o/)
+    test(/f[^\w%&]o/)
+    test(/f[^\w]o/)
+  end
+
+  describe "control characters" do
+    test(/f\no/)
+    test(/f\so/)
+    test(/f\ro/)
+    test(/f\to/)
+    test(/f\vo/)
+    test(/f\fo/)
+    test(/f\ao/)
+    test(/f\eo/)
+    test(/f\345o/)
+    test(/f\345123o/)
+    test(/f\xAFo/)
+    test(/f\xAF12o/)
+    test(/f\u04AFo/u)
+    test(/f\u04AF00o/u)
+    test(/f\qo/)
+  end
+
+  describe "control characters in character classes" do
+    test(/f[\n]o/)
+    test(/f[\s]o/)
+    test(/f[\r]o/)
+    test(/f[\t]o/)
+    test(/f[\v]o/)
+    test(/f[\f]o/)
+    test(/f[\a]o/)
+    test(/f[\e]o/)
+    test(/f[\345]o/)
+    test(/f[\xAF]o/)
+    test(/f[\u04AF]o/u)
+    test(/f[\q]o/)
+  end
+
+  describe "repeated letters" do
+    test(/fo*o/)
+    test(/fo+o/)
+    test(/fo{2}o/)
+    test(/fo{2,}o/)
+    test(/fo{2,4}o/)
+    test(/fo?o/)
+  end
+
+  describe "repeated escape characters" do
+    test(/f\n*o/)
+    test(/f\n+o/)
+    test(/f\n{2}o/)
+    test(/f\n{2,5}o/)
+    test(/f\n?o/)
+    test(/f\345*o/)
+    test(/f\345+o/)
+    test(/f\345{2}o/)
+    test(/f\345{2,}o/)
+    test(/f\345{2,4}o/)
+    test(/f\345?o/)
+    test(/f\xAF*o/)
+    test(/f\xAF+o/)
+    test(/f\xAF{2}o/)
+    test(/f\xAF{2,}o/)
+    test(/f\xAF{2,4}o/)
+    test(/f\xAF?o/)
+    test(/f\u04AF*o/u)
+    test(/f\u04AF+o/u)
+    test(/f\u04AF{2}o/u)
+    test(/f\u04AF{2,}o/u)
+    test(/f\u04AF{2,4}o/u)
+    test(/f\u04AF?o/u)
+    test(/f\q+o/)
+    test(/f\q*o/)
+    test(/f\q{2}o/)
+    test(/f\q{2,}o/)
+    test(/f\q{2,4}o/)
+    test(/f\q?o/)
+  end
+
+  describe "escaped special characters" do
+    test(/\//)
+    test(/#{Expgen::NON_LITERALS}/)
+    test(/}{/)
+    test(/\{\}/)
+  end
+
+  describe "the wildcard character" do
+    test(/f.*o/)
+    test(/f.+o/)
+    test(/f.{2}o/)
+    test(/f.{2,}o/)
+    test(/f.{2,4}o/)
+    test(/f.?o/)
+  end
+
+  describe "special char inside character class" do
+    test(/f[.]o/)
+    test(/f[\\]o/)
+    test(/f[a^]o/)
+    test(/f[$]o/)
+    test(/f[|]o/)
+    test(/f[?]o/)
+    test(/f[*]o/)
+    test(/f[+]o/)
+    test(/f[(]o/)
+    test(/f[)]o/)
+    test(/f[{]o/)
+    test(/f[}]o/)
+  end
+
+  describe "optional capture groups" do
+    test(/f(?:foo)o/)
+    test(/f(?:foo|bar)+o/)
+  end
+
+  describe "weird interpolation thing" do
+    test(/f#{/oo/}o/)
+  end
+
+  describe "bracket expressions" do
+    test(/f[[:alnum:]]o/)
+    test(/f[[:alpha:]]o/)
+    test(/f[[:blank:]]o/)
+    test(/f[[:cntrl:]]o/)
+    test(/f[[:digit:]]o/)
+    test(/f[[:graph:]]o/)
+    test(/f[[:lower:]]o/)
+    test(/f[[:print:]]o/)
+    test(/f[[:punct:]]o/)
+    test(/f[[:space:]]o/)
+    test(/f[[:upper:]]o/)
+    test(/f[[:xdigit:]]o/)
+    test(/f[[:word:]]o/)
+    test(/f[[:ascii:]]o/)
+  end
+
+  describe "negated bracket expressions" do
+    test(/f[^[:alnum:]]o/)
+    test(/f[^[:alpha:]]o/)
+    test(/f[^[:blank:]]o/)
+    test(/f[^[:cntrl:]]o/)
+    test(/f[^[:digit:]]o/)
+    test(/f[^[:graph:]]o/)
+    test(/f[^[:lower:]]o/)
+    test(/f[^[:punct:]]o/)
+    test(/f[^[:space:]]o/)
+    test(/f[^[:upper:]]o/)
+    test(/f[^[:xdigit:]]o/)
+    test(/f[^[:word:]]o/)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require "expgen"
+require "pry"
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: expgen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jonas Nicklas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parslet
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: pry
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Generate random strings from regular expression
+email:
+- jonas.nicklas@gmail.com
+executables:
+- expgen
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/expgen
+- expgen.gemspec
+- lib/expgen.rb
+- lib/expgen/nodes.rb
+- lib/expgen/parser.rb
+- lib/expgen/randomizer.rb
+- lib/expgen/transform.rb
+- lib/expgen/version.rb
+- spec/expgen_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Generate random regular expression
+test_files:
+- spec/expgen_spec.rb
+- spec/spec_helper.rb
+has_rdoc: