rantly 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Howard Yeh
+
+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.textile

@@ -0,0 +1,296 @@
+h1. Imperative Random Data Generator and Quickcheck
+
+You can use Rant to generate random test data, and use its Test::Unit extension for property-based testing.
+
+Rant is basically a recursive descent interpreter, each of its method returns a random value of some type (string, integer, float, etc.).
+
+Its implementation has no alien mathematics inside. Completely side-effect-free-free.
+
+h1. Install
+
+<pre><code>
+$ gem install hayeah-rant --source http://gems.github.com
+</code></pre>
+
+<pre><code>
+$ irb
+> gem 'rant'
+> require 'rant'
+> Rant.gen.value { [integer,float] }
+=> [20991307, 0.025756845811823]
+> Rant.gen.value { [integer,float]}
+=> [-376856492, 0.452245765751706]
+</code></pre>
+
+
+h1. Data Generation
+
+You can create random generators from the Rant class. Rant.gen is just returns a class instance of Rant.
+
+<pre><code>
+> gen = Rant.new
+> gen.value { [integer,float] }
+=> [-163260081, 0.356075765934108]
+</code></pre>
+
+h2. Getting Random Data Values
+
+<pre><code>
+Rant#map(n,limit=10)
+  call the generator n times, and collect values
+Rant#each(n,limit=10)
+  call a random block n times
+Rant#value(limit=10)
+  call a random block once, and get its value.
+</code></pre>
+
+To collect an array of random data,
+
+<pre><code>
+# we want 5
+> gen.map(5) { integer }
+=> [-380638946, -29645239, 344840868, 308052180, -154360970]
+</code></pre>
+
+To iterate over random data,
+
+<pre><code>
+> gen.each(5) { puts integer }
+296971291
+504994512
+-402790444
+113152364
+502842783
+=> nil
+</code></pre>
+
+To get one value of random data,
+
+<pre><code>
+> gen.value { integer }
+=> 278101042
+</code></pre>
+
+The optional argument @limit@ is used with generator guard. By default, if you want to generate n items, the generator tries at most n * 10 times.
+
+This almost always succeeds,
+
+<pre><code>
+> gen.map(5) { i = integer; guard i > 0; i }
+=> [511765059, 250554234, 305947804, 127809156, 285960387]
+</code></pre>
+
+This always fails,
+
+<pre><code>
+> gen.map(10) { guard integer.is_a?(Float) }
+Rant::TooManyTries: Exceed gen limit 100: 101 failed guards)
+</code></pre>
+
+h2. Random Generating Methods
+
+The API is similiar to QuickCheck, but not exactly the same. In particular @choose@ picks a random element from an array, and @range@ picks a integer from an interval.
+
+h3. Simple Randomness
+
+<pre><code>
+Rant#integer(n=nil)
+  random positive or negative integer. Fixnum only.
+Rant#range(lo,hi)
+  random integer between lo and hi.
+Rant#float
+  random float
+Rant#bool
+  true or false
+Rant#literal(value)
+  No-op. returns value.
+Rant#choose(*vals)
+  Pick one value from among vals.
+</code></pre>
+
+h3. Meta Randomness
+
+A rant generator is just a mini interpreter. It's often useful to go meta,
+
+<pre><code>
+Rant#call(gen)
+  If gen is a Symbol, just do a method call with send.
+  If gen is an Array, the first element of the array is the method name, the rest are args.
+  If gen is a Proc, instance_eval it with the generator.
+</code></pre>
+
+<pre><code>
+> gen.value { call(:integer) }
+=> -240998958
+</code></pre>
+
+<pre><code>
+> gen.value { call([:range,0,10]) }
+=> 2
+</code></pre>
+
+<pre><code>
+> gen.value { call(Proc.new { [integer] })}
+=> [522807620]
+</code></pre>
+
+The @call@ method is useful to implement other abstractions (See next subsection).
+
+<pre><code>
+Rant#branch(*args)
+  Pick a random arg among args, and Rant#call it.
+</code></pre>
+
+50-50 chance getting an integer or float,
+
+<pre><code>
+> gen.value { branch :integer, :float }
+=> 0.0489446702931332
+> gen.value { branch :integer, :float }
+=> 494934533
+</code></pre>
+
+
+h3. Frequencies
+
+<pre><code>
+Rant#freq(*pairs)
+  Takes a list of 2-tuples, the first of which is the weight, and the second a Rant#callable value, and returns a random value picked from the pairs. Follows the distribution pattern specified by the weights.
+</code></pre>
+
+Twice as likely to get a float than integer. Never gets a ranged integer.
+
+<pre><code>
+> gen.value { freq [1,:integer], [2,:float], [0,:range,0,10] }
+</code></pre>
+
+If the "pair" is not an array, but just a symbol, @freq@ assumes that the weight is 1.
+
+<pre><code>
+# 50-50 between integer and float
+> gen.value { freq :integer, :float }
+</code></pre>
+
+If a "pair" is an Array, but the first element is not an Integer, @freq@ assumes that it's a Rant method-call with arguments, and the weight is one.
+
+<pre><code>
+# 50-50 chance generating integer limited by 10, or by 20.
+> gen.value { freq [:integer,10], [:integer 20] }
+</code></pre>
+
+
+
+h3. Sized Structure
+
+A Rant generator keeps track of how large a datastructure it should generate with its @size@ attribute.
+
+<pre><code>
+Rant#size
+ returns the current size
+Rant#sized(n,&block)
+ sets the size for the duration of recursive call of block. Block is instance_eval with the generator.
+</code></pre>
+
+Rant provides two methods that depends on the size
+
+<pre><code>
+Rant#array(*branches)
+  returns a sized array consisted of elements by Rant#calling random branches.
+Rant#string(char_class=:print)
+  returns a sized random string, consisted of only chars from a char_class.
+</code></pre>
+
+The avaiable char classes for strings are:
+
+<pre><code>
+:alnum
+:alpha
+:blank
+:cntrl
+:digit
+:graph
+:lower
+:print
+:punct
+:space
+:upper
+:xdigit
+:ascii
+</code></pre>
+
+<pre><code>
+# sized 10 array of integer or float
+> gen.value { sized(10) { array(:integer,:float)}}
+=> [417733046, -375385433, 0.967812380000118, 26478621, 0.888588160450082, 250944144, 305584916, -151858342, 0.308123867823313, 0.316824642414253]
+
+# fails if you forget to set the size.
+> gen.value { array(:integer,:float)}
+RuntimeError: size not set
+
+</code></pre>
+
+If you set the size once, it applies to all subsequent recursive structures. Here's a sized 10 array of sized 10 strings,
+
+<pre><code>
+> gen.value { sized(10) { array(:string)} }
+=> ["1c}C/,9I#}", "hpA/UWPJ\\j", "H'~ERtI`|]", "%OUaW\\%uQZ", "Z2QdY=G~G!", "H<o|<FARGQ", "g>ojnxGDT3", "]a:L[B>bhb", "_Kl=&{tH^<", "ly]Yfb?`6c"]
+</code></pre>
+
+Or a sized 10 array of sized 5 strings,
+
+<pre><code>
+> gen.value { sized(10) { array Proc.new {sized(5) {string}}}}
+=> ["S\"jf ", "d\\F-$", "-_8pa", "IN0iF", "SxRV$", ".{kQ7", "6>;fo", "}.D8)", "P(tS'", "y0v/v"]
+</code></pre>
+
+Rant#array actually just delegate to Rant#freq, so you can use freq pairs:
+
+<pre><code>
+> gen.value { sized(10) {array [1,:integer],[2,:float] }}
+=> [0.983334733158678, -418176338, 0.976947175363592, 0.703390570421286, -478680395, 5483631, 0.966944106783513, 110469205, 0.540859146793544, 0.521813810037025]
+</code></pre>
+
+
+h1. Property Testing
+
+Rant extends Test::Unit for property testing. The extension is in its own module. So you need to require it.
+
+<pre><code>
+require 'rant/check'
+</code></pre>
+
+It defines,
+
+<pre><code>
+Test::Unit::Assertions#property_of(&block)
+  The block is used to generate random data with a generator. The method returns a Rant::Property instance, that has the method 'check'.
+</code></pre>
+
+It's like this, using the gem 'shoulda'
+
+<pre><code>
+# checks that integer only generates fixnum.
+should "generate Fixnum only" do
+   property_of  { integer }.check { |i| assert i.is_a?(Integer) }
+end
+</code></pre>
+
+The check block takes the generated data as its argument. One idiom I find useful is to include a parameter of the random data for the check argument. For example, if I want to check that Rant#array generates the right sized array, I could say,
+
+<pre><code>
+should "generate right sized array" do
+  property_of {
+    len = integer
+    [len,sized(len) { array :integer }]
+  }.check { |(len,arr)|
+    assert_equal len, arr.length
+  }
+end
+</code></pre>
+
+That's about it. Enjoy :)
+
+
+h1. Copyright
+
+Copyright (c) 2009 Howard Yeh. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rantly"
+    gem.summary = %Q{Ruby Imperative Random Data Generator and Quickcheck}
+    gem.email = "hayeah@gmail.com"
+    gem.homepage = "http://github.com/hayeah/rantly"
+    gem.authors = ["Howard Yeh"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rant #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/Rant.gemspec

@@ -0,0 +1,54 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{Rant}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Howard Yeh"]
+  s.date = %q{2009-10-01}
+  s.email = %q{hayeah@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "Rant.gemspec",
+     "VERSION.yml",
+     "lib/rant.rb",
+     "lib/rant/check.rb",
+     "lib/rant/data.rb",
+     "lib/rant/generator.rb",
+     "lib/rant/silly.rb",
+     "test/rant_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/hayeah/rant}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Ruby Imperative Random Data Generator and Quickcheck}
+  s.test_files = [
+    "test/rant_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/VERSION.yml

@@ -0,0 +1,5 @@
+--- 
+:major: 0
+:minor: 1
+:build: 
+:patch: 0

data/lib/rant.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+class Rant
+end
+
+require 'rant/generator'

data/lib/rant/data.rb

@@ -0,0 +1,13 @@
+module Rant::Data
+  def email
+    "#{string(:alnum)}@#{string(:alnum)}.#{sized(3){string(:alpha)}}".downcase
+  end
+
+  def password
+    sized(8) { string(:alnum) }
+  end
+end
+
+class Rant
+  include Rant::Data
+end

data/lib/rant/generator.rb

@@ -0,0 +1,263 @@
+class Rant
+
+  class << self
+    attr_writer :default_size
+    def singleton
+      @singleton ||= Rant.new
+      @singleton
+    end
+
+    def default_size
+      @default_size || 6
+    end
+
+    def gen
+      self.singleton
+    end
+  end
+
+  class GuardFailure < RuntimeError
+  end
+
+  class TooManyTries < RuntimeError
+    
+    def initialize(limit,nfailed)
+      @limit = limit
+      @nfailed = nfailed
+    end
+
+    def tries
+      @nfailed
+    end
+
+    def to_s
+      "Exceed gen limit #{@limit}: #{@nfailed} failed guards)"
+    end
+  end
+
+  # limit attempts to 10 times of how many things we want to generate
+  def each(n,limit=10,&block)
+    generate(n,limit,block)
+  end
+
+  def map(n,limit=10,&block)
+    acc = []
+    generate(n,limit,block) do |val|
+      acc << val
+    end
+    acc
+  end
+
+  def value(limit=10,&block)
+    generate(1,limit,block) do |val|
+      return val
+    end
+  end
+
+  def generate(n,limit_arg,gen_block,&handler)
+    limit = n * limit_arg
+    nfailed = 0
+    nsuccess = 0
+    while nsuccess < n
+      raise TooManyTries.new(limit_arg*n,nfailed) if limit < 0
+      begin
+        val = self.instance_eval(&gen_block)
+      rescue GuardFailure
+        nfailed += 1
+        limit -= 1
+        next
+      end
+      nsuccess += 1
+      limit -= 1
+      handler.call(val) if handler
+    end
+  end
+  
+  attr_accessor :classifiers
+
+  def initialize
+    reset
+  end
+
+  def reset
+    @size = nil
+    @classifiers = Hash.new(0)
+  end
+
+  def classify(classifier)
+    @classifiers[classifier] += 1
+  end
+
+  def guard(test)
+    raise GuardFailure.new unless test
+  end
+
+  def size
+    @size || Rant.default_size
+  end
+  
+  def sized(n,&block)
+    raise "size needs to be greater than zero" if n < 0
+    old_size = @size
+    @size = n
+    r = self.instance_eval(&block)
+    @size = old_size
+    return r
+  end
+
+  # wanna avoid going into Bignum when calling range with these.
+  INTEGER_MAX = (2**(0.size * 8 -2) -1) / 2
+  INTEGER_MIN = -(INTEGER_MAX)
+  def integer(limit=nil)
+    case limit
+    when Range
+      hi = limit.end
+      lo = limit.begin
+    when Integer
+      raise "n should be greater than zero" if limit < 0
+      hi, lo = limit, -limit
+    else
+      hi, lo = INTEGER_MAX, INTEGER_MIN
+    end
+    range(lo,hi)
+  end
+
+  def positive_integer
+    range(0)
+  end
+
+  def float
+    rand
+  end
+
+  def range(lo=nil,hi=nil)
+    lo ||= INTEGER_MIN
+    hi ||= INTEGER_MAX
+    rand(hi+1-lo) + lo
+  end
+
+  def call(gen,*args)
+    case gen
+    when Symbol
+      return self.send(gen,*args)
+    when Array
+      raise "empty array" if gen.empty?
+      return self.send(gen[0],*gen[1..-1])
+    when Proc
+      return self.instance_eval(&gen)
+    else
+      raise "don't know how to call type: #{gen}"
+    end
+  end
+
+  def branch(*gens)
+    self.call(choose(*gens))
+  end
+
+  def choose(*vals)
+    vals[range(0,vals.length-1)]
+  end
+
+  def literal(value)
+    value
+  end
+
+  def boolean
+    range(0,1) == 0 ? true : false
+  end
+
+  def freq(*pairs)
+    pairs = pairs.map do |pair|
+      case pair
+      when Symbol, String, Proc
+        [1,pair]
+      when Array
+        unless pair.first.is_a?(Integer)
+          [1] + pair
+        else
+          pair
+        end
+      end
+    end
+    total = pairs.inject(0) { |sum,p| sum + p.first }
+    raise(RuntimeError, "Illegal frequency:#{pairs.inspect}") if total == 0
+    pos = range(1,total)
+    pairs.each do |p|
+      weight, gen, *args = p
+      if pos <= p[0]
+        return self.call(gen,*args)
+      else
+        pos -= weight
+      end
+    end
+  end
+
+  def array(*freq_pairs)
+    acc = []
+    self.size.times { acc << freq(*freq_pairs) }
+    acc
+  end
+
+  module Chars
+    
+    class << self
+      ASCII = ""
+      (0..127).to_a.each do |i|
+        ASCII << i
+      end
+
+      def of(regexp)
+        ASCII.scan(regexp).to_a.map! { |char| char[0] }
+      end
+    end
+    
+    ALNUM = Chars.of /[[:alnum:]]/
+    ALPHA = Chars.of /[[:alpha:]]/
+    BLANK = Chars.of /[[:blank:]]/
+    CNTRL = Chars.of /[[:cntrl:]]/
+    DIGIT = Chars.of /[[:digit:]]/
+    GRAPH = Chars.of /[[:graph:]]/
+    LOWER = Chars.of /[[:lower:]]/
+    PRINT = Chars.of /[[:print:]]/
+    PUNCT = Chars.of /[[:punct:]]/
+    SPACE = Chars.of /[[:space:]]/
+    UPPER = Chars.of /[[:upper:]]/
+    XDIGIT = Chars.of /[[:xdigit:]]/
+    ASCII = Chars.of /./
+    
+    
+    CLASSES = {
+      :alnum => ALNUM,
+      :alpha => ALPHA,
+      :blank => BLANK,
+      :cntrl => CNTRL,
+      :digit => DIGIT,
+      :graph => GRAPH,
+      :lower => LOWER,
+      :print => PRINT,
+      :punct => PUNCT,
+      :space => SPACE,
+      :upper => UPPER,
+      :xdigit => XDIGIT,
+      :ascii => ASCII,
+    }
+    
+  end
+
+  def string(char_class=:print)
+    chars = case char_class
+            when Regexp
+              Chars.of(char_class)
+            when Symbol
+              Chars::CLASSES[char_class]
+            end
+    raise "bad arg" unless chars
+    str = ""
+    size.times do
+      str << choose(*chars)
+    end
+    str
+  end
+end
+
+

data/lib/rant/property.rb

@@ -0,0 +1,50 @@
+require 'rant'
+require 'test/unit'
+require 'pp'
+
+class Rant::Property
+
+  def initialize(property)
+    @property = property
+  end
+  
+  def check(n=100,limit=10,&assertion)
+    i = 0
+    test_data = nil
+    begin
+      Rant.singleton.generate(n,limit,@property) do |val|
+        test_data = val
+        assertion.call(val) if assertion
+        puts "" if i % 100 == 0
+        print "." if i % 10 == 0
+        i += 1
+      end
+      puts
+      puts "success: #{i} tests"
+    rescue Rant::TooManyTries => e
+      puts
+      puts "too many tries: #{e.tries}"
+      raise e
+    rescue => boom
+      puts
+      puts "failure: #{i} tests, on:"
+      pp test_data
+      raise boom
+    end
+  end
+
+  def report
+    distribs = self.classifiers.sort { |a,b| b[1] <=> a[1] }
+    total = distribs.inject(0) { |sum,pair| sum + pair[1]}
+    distribs.each do |(classifier,count)|
+      format "%10.5f%% of => %s", count, classifier
+    end
+  end
+end
+
+module Test::Unit::Assertions
+  def property_of(&block)
+    Rant::Property.new(block)
+  end
+end
+

data/lib/rant/silly.rb

@@ -0,0 +1,116 @@
+require 'rant'
+module Rant::Silly
+  class << self
+    def love_letter(n)
+      Rant.new.extend(Rant::Silly::Love).value { letter(n) }
+    end
+  end
+end
+
+module Rant::Silly::Love
+
+  def letter(n=3)
+    body = sized(n) { array(:paragraph) }.join "\n\n"
+    <<-EOS
+#{address}:
+
+#{body}
+
+#{sign}
+
+#{post_script}
+EOS
+  end
+  
+  def address
+    "my #{extremifier} #{pedestal_label}"
+  end
+
+  def extremifier
+    choose "most","ultimate","unbelievable","incredible","burning"
+  end
+
+  def pedestal_label
+    choose "beloved","desire","dove","virgin goddess","existential solution","lighthouse","beacon","holy mother","queen","mistress"
+  end
+
+  def double_plus_good
+    choose "holy","shiny","glittering","joyous","delicious"
+  end
+
+  def how_i_feel
+    choose "my heart aches","my spine pines","my spirit wanders and wonders","my soul is awed","my loin burns"
+  end
+
+  def paragraph
+    sized(range(2,4)) { array(:sentence)}.join " "
+  end
+
+  def sentence
+    freq \
+    Proc.new { "when #{how_i_feel}, my #{pedestal_label}, i feel the need to #{stalk_action}, but this is not because #{how_i_feel}, but rather a symptom of my being your #{whoami}." },
+    Proc.new { "because you are my #{pedestal_label}, and i am your #{whoami}, no, rather your #{whoami}, #{fragment}."},
+    Proc.new { "do not think that saying '#{how_i_feel}' suffices to show the depth of how #{how_i_feel}, because more than that, #{fantasy}"},
+    Proc.new { "as a #{whoami}, that #{how_i_feel} is never quite enough for you, my #{double_plus_good} #{pedestal_label}."}
+  end
+
+  def fragment
+    fun = fantasy
+    choose "i hope to god #{fun}", "i believe #{fun}", "i will that #{fun}"
+  end
+
+  def caused_by
+    
+  end
+  
+  def whoami
+    "#{extremifier} #{humbleizer} #{groveler}"
+  end
+
+  def sign
+    "your #{whoami}"
+  end
+
+  def humbleizer
+    choose "undeserving","insignificant","unremarkable","fearful","menial"
+  end
+
+  def groveler
+    choose "slave","servant","captive","lapdog"
+  end
+
+  def post_script
+    "ps: #{i_am_stalking_you}, and hope that #{fantasy}"
+  end
+
+  def i_am_stalking_you
+    "every #{time_duration} i #{stalk_action}"
+  end
+
+  def fantasy
+    freq \
+    Proc.new {
+      make = choose "raise","nurture","bring into the world"
+      babies = choose "brood of babies","#{double_plus_good} angels"
+      good = double_plus_good
+      effect = choose "the world becomes all the more #{good}",
+                      "we may at the end of our lives rest in #{good} peace.",
+                      "you, my #{pedestal_label}, would continue to live."
+      "we would #{make} #{babies}, so #{effect}."
+    },
+    Proc.new {
+      do_thing = choose "kiss","hug","read poetry to each other","massage","whisper empty nothings into each others' ears","be with each other, and oblivious to the entire world"
+      affect = choose "joy", "mindfulness", "calm", "sanctity"
+      "we would #{do_thing} with #{double_plus_good} #{affect}"
+    }
+  end
+
+  def stalk_action
+    choose "think of you","dream of us together","look at your picture and sigh"
+  end
+
+  def time_duration
+    choose "once in a while","night","day","hour","minute"
+  end
+end
+

data/lib/rant/spec.rb

@@ -0,0 +1,10 @@
+require 'rant'
+module Rant::Check
+  def check(n=100,&block)
+    Rant.gen.each(n,&block)
+  end
+
+  def sample(n=100,&block)
+    Rant.gen.map(n,&block)
+  end
+end

data/rantly.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rantly}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Howard Yeh"]
+  s.date = %q{2009-11-30}
+  s.email = %q{hayeah@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "Rant.gemspec",
+     "VERSION.yml",
+     "lib/rant.rb",
+     "lib/rant/data.rb",
+     "lib/rant/generator.rb",
+     "lib/rant/property.rb",
+     "lib/rant/silly.rb",
+     "lib/rant/spec.rb",
+     "rantly.gemspec",
+     "test/rant_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/hayeah/rantly}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Ruby Imperative Random Data Generator and Quickcheck}
+  s.test_files = [
+    "test/rant_test.rb",
+     "test/test_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/rant_test.rb

@@ -0,0 +1,284 @@
+require 'test_helper'
+require 'rant/check'
+
+module RantTest
+end
+
+# check we generate the right kind of data.
+## doesn't check for distribution
+class RantTest::Generator < Test::Unit::TestCase
+  def setup
+    Rant.gen.reset
+  end
+  
+  should "fail test generation" do
+    assert_raises(Rant::TooManyTries) {
+      property_of { guard range(0,1) < 0 }.check
+    }
+  end
+
+  should "generate literal value by returning itself" do
+    property_of {
+      i = integer
+      [i,literal(i)]
+    }.check { |(a,b)|
+      assert_equal a, b
+    }
+  end
+
+  should "generate integer in range" do
+    property_of {
+      i = integer
+      [i,range(i,i)]
+    }.check { |(a,b)|
+      assert_equal a, b
+    }
+    property_of {
+      lo, hi = [integer(100),integer(100)].sort
+      [lo,hi,range(lo,hi)]
+    }.check { |(lo,hi,int)|
+      assert((lo..hi).include?(int)) 
+    }
+  end
+
+  should "generate Fixnum only" do
+    property_of  { integer }.check { |i| assert i.is_a?(Integer) }
+  end
+
+  should "generate integer less than abs(n)" do
+    property_of {
+      n = range(0,10)
+      [n,integer(n)]
+    }.check {|(n,i)|
+      assert n.abs >= i.abs
+    }
+  end
+
+  should "generate Float" do
+    property_of { float }.check { |f| assert f.is_a?(Float)}
+  end
+
+  should "generate Boolean" do
+    property_of { bool }.check { |t|
+      assert t == true || t == false
+    }
+  end
+
+  should "generate empty strings" do
+    property_of {
+      sized(0) { string }
+    }.check { |s|
+      assert s.empty?
+    }
+  end
+
+  should "generate strings with the right regexp char classes" do
+    char_classes = Rant::Chars::CLASSES.keys
+    property_of {
+      char_class = choose(*char_classes)
+      len = range(0,10)
+      sized(len) { [len,char_class,string(char_class)]}
+    }.check { |(len,char_class,str)|
+      t = true
+      chars = Rant::Chars::CLASSES[char_class]
+      str.each_byte { |c|
+        unless chars.include?(c)
+          t = false
+          break
+        end
+      }
+      assert_equal len, str.length
+      assert t
+    }
+  end
+
+  should "generate strings matching regexp" do
+    property_of {
+      sized(10) { string(/[abcd]/) }
+    }.check { |s|
+      assert s =~ /[abcd]+/
+    }
+  end
+
+  # call
+
+  should "call Symbol as method call (no arg)" do
+    property_of {call(:integer)}.check { |i| i.is_a?(Integer)}
+  end
+
+  should "call Symbol as method call (with arg)" do
+    property_of {
+      n = range(0,100)
+      [n,call(:integer,n)]
+    }.check { |(n,i)|
+      assert n.abs >= i.abs
+    }
+  end
+
+  should "call Array by calling first element as method, the rest as args" do
+    assert_raise(RuntimeError) {
+      Rant.gen.value {
+        call []
+      }
+    }
+    property_of {
+      i = integer
+      [i,call(choose([:literal,i],[:range,i,i]))]
+    }.check { |(a,b)|
+      assert_equal a, b
+    }
+  end
+  
+  should "call Proc with generator.instance_eval" do
+    property_of {
+      call Proc.new { true }
+    }.check { |o|
+      assert_equal true, o
+    }
+    property_of {
+      i0 = range(0,100)
+      i1,s = call Proc.new {
+        range(i0+1,i0+100)
+      }
+      [i0,i1]
+    }.check { |(i0,i1)|
+      assert i0.is_a?(Fixnum) && i1.is_a?(Fixnum)
+      assert i0 != i1
+      assert i1 > i0
+    }
+  end
+  
+  should "raise if calling on any other value" do
+    assert_raise(RuntimeError) {
+      Rant.gen.call 0
+    }
+  end
+
+  # branch
+
+  should "branch by Rant#calling one of the args" do
+    property_of {
+      branch :integer, :integer, :integer
+    }.check { |o|
+      assert o.is_a?(Fixnum)
+    }
+    property_of {
+      sized(10) { branch :integer, :string }
+    }.check { |o|
+      assert o.is_a?(Fixnum) || o.is_a?(String)
+    }
+  end
+
+  
+  # choose
+  
+  should "choose a value from args " do
+    property_of {
+      choose
+    }.check {|o|
+      assert_nil o
+    }
+    property_of {
+      choose 1
+    }.check { |o|
+      assert_equal 1, o
+    }
+    property_of {
+      choose 1,2
+    }.check { |o|
+      assert o == 1 || o == 2
+    }
+    property_of {
+      arr = sized(10) { array(:integer) }
+      choose(*arr) 
+    }.check { |o|
+      assert o.is_a?(Fixnum)
+    }
+    property_of {
+      # array of array of ints
+      arr = sized(10) { array(Proc.new { array(:integer)})}
+      # choose an array from an array of arrays of ints
+      choose(*arr)
+    }.check { |arr|
+      assert arr.is_a?(Array)
+      assert arr.all? { |o| o.is_a?(Fixnum)}
+    }
+  end
+
+  # freq
+
+  should "not pick an element with 0 frequency" do
+    property_of {
+      sized(10) {
+        array Proc.new { freq([0,:string],[1,:integer]) }
+      }
+    }.check { |arr|
+      assert arr.all? { |o| o.is_a?(Integer)}
+    }
+  end
+
+  should "handle degenerate freq pairs" do
+    assert_raise(RuntimeError) {
+      Rant.gen.value {
+        freq
+      }
+    }
+    property_of {
+      i = integer
+      [i,freq([:literal,i])]
+    }.check { |(a,b)|
+      assert_equal a, b
+    }
+  end
+
+  # array
+
+  should "generate empty array" do
+    property_of {
+      sized(0) { array(:integer)}
+    }.check { |o|
+      assert o.empty?
+    }
+  end
+  
+  should "generate the right sized nested arrays" do
+    property_of {
+      size1 = range(5,10)
+      size2 = range(0,size1-1)
+      array = sized(size1) { array(Proc.new { sized(size2) { array(:integer)}})}
+      [size1,array]
+    }.check { |(size1,outter_array)|
+      assert_equal size1, outter_array.size
+      assert outter_array.all? { |inner_array| inner_array.size < size1 }
+    }
+  end
+  
+  should "generate array with right types" do
+    property_of {
+      sized(10) { array :integer,:string,:float }
+    }.check { |arr|
+      assert arr.all? { |o|
+        case o
+        when Fixnum, Float, String
+          true
+        else
+          false
+        end
+      }
+    }
+  end
+
+  should "raise if generating an array without size" do
+    assert_raise(RuntimeError) {
+      Rant.gen.value { array(:integer) }
+    }
+  end
+
+end
+  
+
+
+# TODO: check that distributions of different methods look roughly correct.
+class RantTest::Distribution
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rant'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: rantly
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Howard Yeh
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-30 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: 
+email: hayeah@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.textile
+- Rakefile
+- Rant.gemspec
+- VERSION.yml
+- lib/rant.rb
+- lib/rant/data.rb
+- lib/rant/generator.rb
+- lib/rant/property.rb
+- lib/rant/silly.rb
+- lib/rant/spec.rb
+- rantly.gemspec
+- test/rant_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/hayeah/rantly
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby Imperative Random Data Generator and Quickcheck
+test_files: 
+- test/rant_test.rb
+- test/test_helper.rb