randall 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+
+copyright (c) 2010, Diego Che
+
+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.rdoc

@@ -0,0 +1,87 @@
+= Randall
+
+*{Randomly generates instances of any class}*
+
+== Dependencies
+
+Beautiful treetop[http://treetop.rubyforge.org/] is needed for parsing
+regular expressions, so we can generate random character strings matching
+a regexp.
+
+Slim bacon[http://rubygems.org/gems/bacon/] is used for executing specs.
+You need not install bacon to use Randall.
+
+== Install
+
+ gem install randall
+ 
+Randall uses Fiber, so can be used on Ruby 1.9 or JRuby only.
+
+Tested on:
+- ruby 1.9.1 p378
+- jruby 1.5.0 with option --1.9
+ 
+== Examples
+ 
+=== Canonical approach
+
+=== Numbers
+
+=== String
+
+=== Array and Hash
+
+
+=== Objects
+
+ 
+
+=== Syntax sugars
+
+Some methods are provided to specify the type and restrictions.
+
+ r = Randall
+ r.integers.less_than(100)  # Same as r.generate(Integer, :less_than => 100)
+ r.floats.gt(100) # => r.generate(Float, :greater_than => 100)
+ r.floats.clost_to(0)
+ r.integers.in_range(1..2)
+ 
+For generating strings.
+ number = Randall.strings.that.match(/[0-9]+/)
+
+Above example has the same effect as 
+<code>number = Randall.new(String, :like => /[0-9]+/)</code>.
+
+Generate Arrays whose elements are generated by +number+.
+ Randall.arrays.of(number).size(100)
+Generate Hashes whose keys are 
+ Randall.hashes.from(number).to(String).size(10)
+ 
+==== Some monkey patching
+
+- +Array#pick+ randomly pick an element from the receiver. 
+- +Regexp#rand+ generates a String that matches the receiver.
+
+Monkey patching is disabled by default. You must patch explicitly, by calling
++RandallMonkey.patch+.
+
+== Limitations on Generating Strings for Regular Expressions
+
+* Anchors, except +^+ and +$+, are ignored.
+* +\p{*}+ and +\P{*}+ are not supported.
+* Unicode characters are not supported.
+* +(?*)+ extension is not supported.
+* Back-reference is not supported.
+ 
+== License
+
+The MIT license.
+
+Copyright (2010), Diego Che (chekenan@gmail.com)
+
+== Links
+
+* randexp[http://github.com/benburkert/randexp] - generates random data from a Regular Expression. The +Array#pick+ is from here.
+
+* {Source Repository}[http://github.com/benburkert/randexp] - You can also report bugs to the {github issue tracker}[http://github.com/dche/randall/issues].
+

data/lib/randall/charclass.rb

@@ -0,0 +1,186 @@
+# encoding: utf-8
+#
+# charclass.rb -- Character classes parsing for treetop parser.
+#
+# copyright (c) 2010, Diego Che (chekenan@gmail.com)
+#
+
+# The grammar module.
+module RandallRegExp # :nodoc: all
+  module CharSets
+    
+    def strseq(from, to)
+      (from..to).map(&:chr)
+    end
+    
+    def all_chars
+      @@ascii ||= strseq(0, 0x7f)
+    end
+    alias :ascii :all_chars
+    
+    def graph
+      @@graph ||= strseq(0x21, 0x7e)
+    end
+    
+    def control
+      @@control ||= strseq(0, 0x1f) << 0x7f
+    end
+        
+    def decimal_number
+      @@decimal_number ||= (0..9).to_a.map(&:to_s)
+    end
+    alias :digit :decimal_number
+    
+    def lower_letter
+      @@lower_letter ||= 26.times.map do |i|
+        ('a'.ord + i).chr
+      end
+    end
+    
+    def upper_letter
+      @@upper_letter ||= self.lower_letter.map(&:upcase)
+    end
+    
+    def letter
+      @@letter ||= self.lower_letter + self.upper_letter
+    end
+    
+    def space
+      @@space ||= ["\s", "\t", "\r", "\n", "\v", "\f"]
+    end
+    
+    def punctuation
+      # CHECK: which chars belong to this set?
+      @@punct ||= ['!', "\"", '#', #'$', 
+                   '%', '&', "'", '(', ')',
+                   '*', #'+', 
+                   '-', '.', '/', ':', ';', '<', #'=', '>',
+                   '?', '@', '[', '\\', ']', #'^', 
+                   '_', #'`',
+                   '{', #'|', 
+                   '}', #'~'
+                   ]
+    end
+    
+    def xchar
+      c = ['a', 'b', 'c', 'd', 'e']
+      c += c.map(&:upcase)
+    end
+    
+    def xdigit
+      @@xdigit ||= self.digit + self.xchar
+    end
+    
+    def word
+      @@word ||= self.letter + self.digit << '_'
+    end
+  end
+  
+  class CharClass < Treetop::Runtime::SyntaxNode
+    include CharSets
+    
+    # '[' neg:'^'? comp:(cc_comp / char_class)+ amps:('&&' char_class)? ']'
+    def chars
+      return @chars if @chars
+
+      # build charset
+      @chars = comp.elements.map(&:chars).reduce([], :+).uniq
+      @chars &= amps.elements[1].chars unless amps.empty?
+      @chars = self.all_chars - @chars unless neg.empty?
+
+      @chars
+    end
+    
+    def rand
+      self.chars
+    	@chars.empty? ? '' : @chars[Kernel.rand(@chars.size)]
+    end
+  end
+  
+  class PosixCharClass < CharClass
+    
+    def chars
+      return @chars if @chars
+      
+      @chars = case pcc_name.text_value
+			when 'alnum'
+			  self.letter + self.digit
+			when 'alpha'
+			  self.letter
+			when 'ascii'
+			  self.ascii
+			when 'blank'
+			  ["\s", "\t"]
+			when 'cntrl'
+			  self.control
+			when 'digit'
+			  self.digit
+			when 'graph'
+			  self.graph
+			when 'lower'
+			  self.lower
+			when 'print'
+			  self.graph << "\s"
+			when 'punct'
+			  self.punctuation
+			when 'space'
+			  self.space
+			when 'upper'
+			  self.upper
+			when 'xdigit'
+			  self.xdigit
+			when 'word'
+			  self.word
+			else
+				[]
+			end
+
+			@chars = self.all_chars - @chars unless neg.empty?
+			@chars
+    end
+	end
+		
+  class PerlCharClass < CharClass
+    def chars
+      @chars ||= case self.text_value
+      when '\s'
+        self.space
+      when '\S'
+        self.all_chars - self.space
+      when '\d'
+        self.digit
+      when '\D'
+        self.all_chars - self.digit
+      when '\h'
+        self.xdigit
+      when '\H'
+        self.all_chars - self.xdigit
+      when '\w'
+        self.word
+      when '\W'
+        self.all_chars - self.word
+      else
+      	[]
+      end
+    end
+  end
+  
+  class SpanCharClass < CharClass
+    
+    def chars
+      @chars ||= case self.text_value
+      when /([0-9a-zA-Z])\-([0-9a-zA-Z])/
+        $1 <= $2 ? self.strseq($1, $2) : ''
+      else
+        self.text_value.split('').uniq
+      end
+    end
+    
+    def strseq(from, to)
+      (to.ord - from.ord).times.map do |i|
+        (from.ord + i).chr
+      end
+    end
+  end
+
+end

data/lib/randall/monkey_patch.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+#
+# copyright (c) 2010, Diego Che
+#
+
+module RandallMonkey
+  
+  module PickableArray
+    # Randomly pick an element from the receiver.
+    def pick
+      self[Kernel.rand(self.size)]
+    end
+  end
+
+  module RandableRegexp
+    # Generate a String that matches the receiver.
+    def rand
+      @randall ||= Randall.new(String, :like => self)
+      @randall.next
+    end
+  end
+  
+  # Enable the monkey patch.
+  # After this message, you have +Array#pick+ and +Regexp#rand+.
+  def self.patch
+    Array.class_eval do
+      include PickableArray
+    end
+    
+    Regexp.class_eval do
+      include RandableRegexp
+    end
+  end
+  
+end

data/lib/randall/sugar.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+#
+# copyright (c) 2010, Diego Che
+#
+
+module RandallClassSugar
+  def strings
+    self.new(String)
+  end
+  
+  def integers
+    self.new(Integer)
+  end
+  
+  def floats
+    self.new(Float)
+  end
+  
+  def arrays
+    self.new(Array)
+  end
+  
+  def hashes
+    self.new(Hash)
+  end
+  
+  def instances_of(cls)
+    self.new(cls)
+  end
+end
+
+module RandallInstanceSugar
+  def that
+    self
+  end
+  alias :with :that
+  alias :and :that
+  
+  def match(re)
+    unless @type == String then
+      raise ArgumentError, 'Applied to generator for String only.'
+    end
+    
+    self.restrict :like => re
+  end
+  
+  def less_than(number)
+    unless @type == Float or @type == Integer then
+      raise ArgumentError, 'Applied to generator for String only.'
+    end
+    
+    @options[:less_than] = number
+    self
+  end
+  alias :lt :less_than
+  
+  def greater_than(number)
+    unless @type == Float or @type == Integer then
+      raise ArgumentError, 'Applied to generator for number only.'
+    end
+    
+    @options[:greater_than] = number
+    self
+  end
+  alias :gt :greater_than
+  
+  def close_to(f)
+    unless @type == Float then
+      raise ArgumentError, 'Applied to generator for number only.'
+    end
+    
+    @options[:close_to] = f
+    self
+  end
+  
+  def in_range(rg)
+    unless @type == Float or @type == Integer then
+      raise ArgumentError, 'Applied to generator for number only.'
+    end
+    
+    @options[:range] = rg
+    self
+  end
+  alias :between :in_range
+  
+  def of(type)
+    unless @type == Array then
+      raise ArgumentError, 'Applied to generator for Array only.'
+    end
+    
+    case type
+    when Randall
+      @options[:item] = type
+    when Class
+      @options[:type] = type
+    else
+      @options[:type] = type.class
+    end
+    
+    self
+  end
+  
+  def with_size(number)
+    unless @type == Hash or @type == Array then
+      raise ArgumentError, 'Applied to generator for Hash and Array only.'
+    end
+    
+    @options[:size] = number
+    self
+  end
+  
+  def from(type)
+    unless @type == Hash then
+      raise ArgumentError, 'Applied to generator for Hash only.'
+    end
+    
+    case type
+    when Class
+      @options[:key_type] = type
+    when Randall
+      @options[:key] = type
+    else
+      @options[:key_type] = type.class
+    end
+    self
+  end
+  
+  def to(type)
+    unless @type == Hash then
+      raise ArgumentError, 'Applied to generator for Hash only.'
+    end
+    
+    case type
+    when Class
+      @options[:value_type] = type
+    when Randall
+      @options[:value] = type
+    else
+      @options[:value_type] = type.class
+    end
+
+    self
+  end
+  
+  def with_arguments(*args)
+    self.restrict :args => args
+  end
+  
+end

data/lib/randall.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+#
+# randall.rb
+#
+# copyright (c) 2010, Diego Che (chekenan@gmail.com)
+#
+
+require 'treetop'
+
+require File.join(File.dirname(__FILE__), 'randall/charclass')
+Treetop.load File.join(File.dirname(__FILE__), 'regexp')
+
+require File.join(File.dirname(__FILE__), 'randall/sugar')
+require File.join(File.dirname(__FILE__), 'randall/monkey_patch')
+
+# A random value generator.
+#
+# 
+class Randall
+  include RandallInstanceSugar
+  class <<self; self; end.class_eval do
+    include RandallClassSugar
+  end
+  
+  # The generated random value. It is changed after +rand+ or +next+ are
+  # called.
+  attr_reader :value
+  # The +Class+ for which the receiver should generate instances. 
+  attr_reader :type
+  
+  # The regexp parser for generating random String.
+  @@reparser = RandallRegExpParser.new
+
+  # Creates a Randall object.
+  #
+  # [type] Type of the values the Randall object should generate.
+  # [opts] Optional. The restrictions the generated random values should
+  #                  satisfy. See documents of +Randall+ for restrictions
+  #                  of each supported types, and how this arguments is
+  #                  specified.
+  def initialize(type = Integer, opts = {})
+    @type = type
+    
+    self.restrict opts
+    
+    @worker = Fiber.new do
+      loop do
+        if String == @type
+          @value = g_str
+        elsif Integer == @type
+          @value = g_int
+        elsif Float == @type
+          @value = g_float
+        elsif Array == @type
+          @value = g_array
+        elsif Hash == @type
+          @value = g_hash
+        elsif Class === @type
+          @value = g_any
+        else
+          @value = nil
+        end
+
+        Fiber.yield @value
+      end
+    end
+  end
+
+  # Same as +self.value+.
+  def v
+    self.value
+  end
+
+  # Generates value for given type and restrictions.
+  # This method is used when you want to reuse a Randall object to generate
+  # values for alternate type.
+  def rand(type, opts = {})
+    @type = type
+    
+    self.restrict opts
+    @worker.resume
+  end
+  alias :r :rand
+  
+  # Set the restriction. You use this method to change the restrictions
+  # the generated values should satisfy.
+  def restrict(opts)
+    @options = opts
+    parse_regexp if @type == String
+
+    self
+  end
+
+  # Generate another value under current type and restrictions.
+  def next
+    @worker.resume
+  end
+  alias :n :next
+
+  private
+
+  def g_str
+    @str_gen.rand
+  end
+
+  def g_int
+    @options.delete :close_to
+    Integer(g_float)
+  end
+
+  def g_float
+    if @options[:close_to]
+      epsilon = @options[:epsilon] || 1e-3
+      @options[:close_to] - epsilon + Kernel.rand * (2 * epsilon)
+    elsif @options[:range]
+      min = @options[:range].min
+      max = @options[:range].max
+
+      min + Kernel.rand * (max - min)
+    elsif @options[:greater_than] or @options[:less_than]      
+      max = @options[:less_than] || 10 ** 24
+      min = @options[:greater_than] || max - 10 ** 24
+      
+      if min >= max
+        if @options[:greater_than] and @options[:less_than]
+          raise ArgumentError, ":less_than(#{max}) should be greater than :grater_than(#{min})."
+        elsif @options[:greater_than]
+          max = min + 10 ** 24
+        end
+      end
+      min + Kernel.rand * (max - min)
+    else
+      Kernel.rand * (10 ** 6)
+    end
+  end
+
+  def g_array
+    sz = @options[:size] || rand_size
+    item_gen = @options[:item] || self.class.new(@options[:type] || rand_type)
+
+    v = []
+    sz.times do
+      v << item_gen.next
+    end
+    v
+  end
+
+  def g_hash
+    sz = @options[:size] || rand_size
+    key_gen = @options[:key] || self.class.new(@options[:key_type] || rand_type)
+    value_gen = @options[:value] || self.class.new(@options[:value_type] || rand_type)
+
+    v = {}
+    dup_retry = 3
+    sz.times do
+      k = key_gen.next while v[k] && (dup_retry -= 1) > 0
+      v[key_gen.next] = value_gen.next
+    end
+    if v.size < sz && @options[:size]
+      $stderr.puts "[Warning]: The key space is too small to generate #{sz} pairs."
+      $stderr.puts key_gen.type
+    end
+    v
+  end
+
+  # Generate an Object.
+  def g_any
+    begin
+      args = @options[:args] || []
+      args = [] unless args.is_a? Array
+
+      @type.new *args
+    rescue Exception  # catch all exceptions
+      nil
+    end
+  end
+  
+  def rand_size(max = 100)
+    Kernel.rand max
+  end
+  
+  def rand_type
+    [Integer, Float, String][Kernel.rand 3]
+  end
+
+  def parse_regexp
+    return self unless @type == String
+    re = @options[:like].is_a?(Regexp) ? @options[:like] : /.+/
+    
+    @str_gen = @@reparser.parse re.source
+    raise RuntimeError, "Randall is not strong enough (yet) to handle regexp: #{re.inspect}" if @str_gen.nil?
+    
+    self
+  end
+end

data/lib/regexp.treetop

@@ -0,0 +1,180 @@
+# encoding: utf-8
+# 
+# copyright (c) 2010, Diego Che (chekenan@gmail.com)
+# 
+
+grammar RandallRegExp
+	rule regexp
+		pre:'^'? exp_body post:'$'? {
+			include CharSets
+					
+			def rand
+				(pre.empty? ? self.any_str : '') +
+				exp_body.rand +
+				(post.empty? ? self.any_str : '')
+			end
+			
+			def any_str
+				''
+			end
+		}
+	end
+	
+	rule exp_body
+		clause rc:clause* sel:choice? {
+			def rand
+				head = clause.rand + rc.elements.map(&:rand).reduce('', :+)
+				unless sel.empty? then
+					Kernel.rand(2) == 0 ? head : sel.rand
+				else
+					head
+				end
+			end
+		}
+	end
+	
+	rule clause
+		distinguishable q:quantifier? opt:'?'? {
+			def rand
+				(q.empty? ? 1 : q.repeatition).times.map do
+					distinguishable.rand
+				end.reduce('', :+)
+			end
+		}
+	end
+	
+	rule distinguishable
+		group / constants / char_class / escapes / '.' {
+			include CharSets
+			
+			def rand
+				g = self.graph
+				g[Kernel.rand(g.size)]
+			end
+		}
+	end
+	
+	rule group
+		'(' exp_body ')' {
+			def rand
+				exp_body.rand
+			end
+		}
+	end
+		
+	rule choice
+	 	'|' exp_body {
+			def rand
+				exp_body.rand
+			end
+		}
+	end
+	
+	rule constants
+		[^\\\[\(\{\*\.\+\?\]\}\)\^\$\|] {
+			def rand
+				self.text_value
+			end
+		}
+	end
+	
+	rule char_class
+		'\\' char_class_escape <PerlCharClass>
+		/ '[' neg:'^'? comp:(cc_comp / char_class)+ amps:('&&' char_class)? ']' <CharClass>
+	end
+		
+	rule char_class_escape
+		'd' / 'D' / 'h' / 'H' / 's' / 'S' / 'w' / 'W' / encoding_property
+	end
+	
+	rule encoding_property
+		('p' / 'P') '{' neg:'^'? encoding '}'
+	end
+	
+	rule encoding
+		'Alnum' / 'Alpha' / 'Blank' / 'Cntrl' / 'Digit' / 'Graph'
+		/ 'Lower' / 'Print' / 'Punct' / 'Space' / 'Upper' / 'XDigit'
+		/ 'Word' / 'ASCII' / [a-zA-Z]+
+	end
+	
+	rule cc_comp
+		posix_char_class / span_char_class / escaped_chars
+	end
+	
+	rule posix_char_class
+		'[:' neg:'^'? pcc_name ':]' <PosixCharClass>
+	end
+	
+	rule pcc_name
+		'alnum' / 'alpha' / 'ascii' / 'blank' / 'cntrl' / 'digit'/ 'graph'
+		/ 'lower' / 'print' / 'punct' / 'space' / 'uppder' / 'xdigit' / 'word'
+	end
+	
+	rule span_char_class
+		[0-9] '-' [0-9] <SpanCharClass>
+		/ [a-z] '-' [a-z] <SpanCharClass>
+		/ [A-Z] '-' [A-Z] <SpanCharClass> 
+		/ [0-9a-zA-Z^$.+*(){}]+ <SpanCharClass>	# TODO: incomplete chars.
+	end
+	
+	rule escaped_chars
+		('\[' / '\]' / '\-' / '\/') {
+			def chars
+				[self.text_value]
+			end
+			
+			def rand
+				self.chars
+				self.text_value[1]
+			end
+		}
+	end
+	
+	rule escapes
+		'\\' [^dDhHsSwWpPx] {
+			def rand
+				case self.text_value
+				when /\\[aAzZbB]/
+					''
+				when /\\x(\d+)/
+					# TODO: ascii only. To support unicode.
+					$1.to_a.chr
+				when '\r'
+					"\r"
+				when '\n'
+					"\n"
+				when '\t'
+					"\t"
+				else 
+					self.text_value[1]
+				end
+			end
+		}
+	end
+	
+	rule quantifier
+		('*' / '+' / '?' / '{' ','? [0-9]+ '}' / '{' [0-9]+ ',' ([0-9]+)? '}') {
+			def repeatition
+				case self.text_value
+				when '*'
+					Kernel.rand(20)
+				when '+'
+					1 + Kernel.rand(20)
+				when '?'
+					Kernel.rand(2)
+				when /\{\,([0-9]+)\}/
+					Kernel.rand($1.to_i + 1)
+				when /\{([0-9]+)\}/
+					$1.to_i
+				when /\{([0-9]+)\,\}/
+					$1.to_i + Kernel.rand(20)
+				when /\{([0-9]+)\,([0-9]+)\}/
+					# TODO: ensure $2 >= $1
+					$1.to_i + Kernel.rand($2.to_i - $1.to_i + 1)
+				else
+					0
+				end
+			end
+		}
+	end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: randall
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Diego Che
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-03 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 4
+        - 7
+        version: 1.4.7
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 1
+        - 0
+        version: 1.1.0
+  type: :development
+  version_requirements: *id002
+description: Generate random instances of any classes.
+email: chekenan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- LICENSE
+- lib/regexp.treetop
+- lib/randall/charclass.rb
+- lib/randall/monkey_patch.rb
+- lib/randall/sugar.rb
+- lib/randall.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- Randall
+- --main
+- README.rdoc
+- --line-numbers
+- --exclude="spec/*"
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 29
+      segments: 
+      - 1
+      - 9
+      version: "1.9"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Generate random instances of any classes.
+test_files: []
+