confabulator 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.2@confabulator --create

data/Gemfile

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

data/README.markdown

@@ -0,0 +1,34 @@
+# Confabulator
+
+A Ruby grammar for procedural generation of random sentences.
+
+## Choice blocks
+
+		> 5.times { puts Confabulator::Parser.new("{Choice one|Choice two} and stuff").confabulate }
+		Choice one and stuff
+		Choice one and stuff
+		...
+		# Recursion is fine!
+		> 5.times { puts Confabulator::Parser.new("{Choice {1|2}|Choice 3} and stuff").confabulate }
+		Choice 1 and stuff
+		Choice 2 and stuff
+		Choice 3 and stuff
+		...
+		# You can differentially weight the options: {5:This is 5 times more likely|than this}
+
+## Substitutions
+
+		> knowledge = Confabulator::Knowledge.new
+		> knowledge.add "world", "there"
+		> Confabulator::Parser.new("Hello, [world]!", :knowledge => knowledge)
+		=> "Hello, there!"
+		# Equivalently:
+		> knowledge.confabulate("Hello, [world]!")
+		=> "Hello, there!"
+		# You can ask a substitution to be capitalized:
+		> knowledge.confabulate("Hello, [world:c]!")
+		=> "Hello, There!"
+		# Or pluralized:
+		> knowledge.add "dude", "friend"
+		> knowledge.confabulate("Hello, [dude:p]!")
+		=> "Hello, friends!"

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+desc "Rebuild the TreeTop grammer parser"
+task :rebuild do
+  grammer = File.expand_path(File.join(File.dirname(__FILE__), "src", "confabulator_language.treetop"))
+  output = File.expand_path(File.join(File.dirname(__FILE__), "lib", "confabulator", "language.rb"))
+  puts `tt #{grammer} -o #{output}`
+end

data/confabulator.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "confabulator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "confabulator"
+  s.version     = Confabulator::VERSION
+  s.authors     = ["Andrew Cantino"]
+  s.email       = ["andrew@iterationlabs.com"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby generative grammer for conversational text}
+  s.description = %q{}
+
+  s.rubyforge_project = "confabulator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec"
+  s.add_runtime_dependency "treetop"
+  s.add_runtime_dependency "linguistics"
+end

data/lib/confabulator.rb

@@ -0,0 +1,6 @@
+require 'treetop'
+require "confabulator/version"
+require 'confabulator/language'
+require 'confabulator/parser'
+require 'confabulator/knowledge'
+require 'pp'

data/lib/confabulator/knowledge.rb

@@ -0,0 +1,36 @@
+module Confabulator
+  class Knowledge
+    def initialize
+    end
+    
+    def find(name)
+      knowledge[name] || empty_confabulator
+    end
+    
+    def add(name, sentence = nil)
+      if name.is_a?(Hash)
+        name.each do |n, s|
+          knowledge[n] = Confabulator::Parser.new(s, :knowledge => self)
+        end
+      else
+        knowledge[name] = Confabulator::Parser.new(sentence, :knowledge => self)
+      end
+    end
+    
+    def empty_confabulator
+      @empty ||= Confabulator::Parser.new("", :knowledge => self)
+    end
+    
+    def knowledge
+      @knowledge ||= {}
+    end
+    
+    def clear
+      @knowledge = {}
+    end
+    
+    def confabulate(sentence)
+      Parser.new(sentence, :knowledge => self).confabulate
+    end
+  end
+end

data/lib/confabulator/language.rb

@@ -0,0 +1,695 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module Confabulator
+	module ConfabulatorLanguage
+   include Treetop::Runtime
+
+   def root
+     @root ||= :sentence
+   end
+
+   module Sentence0
+				def compose(kb = nil)
+					elements.map {|e| e.compose(kb) }.join
+				end
+   end
+
+   def _nt_sentence
+     start_index = index
+     if node_cache[:sentence].has_key?(index)
+       cached = node_cache[:sentence][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     s0, i0 = [], index
+     loop do
+       i1 = index
+       r2 = _nt_substitution
+       if r2
+         r1 = r2
+       else
+         r3 = _nt_choice
+         if r3
+           r1 = r3
+         else
+           r4 = _nt_escaped_char
+           if r4
+             r1 = r4
+           else
+             r5 = _nt_words
+             if r5
+               r1 = r5
+             else
+               @index = i1
+               r1 = nil
+             end
+           end
+         end
+       end
+       if r1
+         s0 << r1
+       else
+         break
+       end
+     end
+     if s0.empty?
+       @index = i0
+       r0 = nil
+     else
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Sentence0)
+     end
+
+     node_cache[:sentence][start_index] = r0
+
+     r0
+   end
+
+   module Choice0
+     def weight
+       elements[0]
+     end
+
+     def sentence
+       elements[1]
+     end
+   end
+
+   module Choice1
+     def weight
+       elements[1]
+     end
+
+     def sentence
+       elements[2]
+     end
+   end
+
+   module Choice2
+     def first_sentence
+       elements[1]
+     end
+
+     def rest_sentences
+       elements[2]
+     end
+
+   end
+
+   module Choice3
+				def compose(kb = nil)
+					elems = []
+					(first_sentence.weight.empty? ? 1 : first_sentence.weight.value).times { elems << first_sentence.sentence }
+					rest_sentences.elements.each do |s|
+						(s.weight.empty? ? 1 : s.weight.value).times { elems << s.sentence }
+					end
+					elems[elems.length * rand].compose(kb)
+				end
+   end
+
+   def _nt_choice
+     start_index = index
+     if node_cache[:choice].has_key?(index)
+       cached = node_cache[:choice][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     i0, s0 = index, []
+     if has_terminal?('{', false, index)
+       r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+       @index += 1
+     else
+       terminal_parse_failure('{')
+       r1 = nil
+     end
+     s0 << r1
+     if r1
+       i2, s2 = index, []
+       r4 = _nt_weight
+       if r4
+         r3 = r4
+       else
+         r3 = instantiate_node(SyntaxNode,input, index...index)
+       end
+       s2 << r3
+       if r3
+         r5 = _nt_sentence
+         s2 << r5
+       end
+       if s2.last
+         r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+         r2.extend(Choice0)
+       else
+         @index = i2
+         r2 = nil
+       end
+       s0 << r2
+       if r2
+         s6, i6 = [], index
+         loop do
+           i7, s7 = index, []
+           if has_terminal?('|', false, index)
+             r8 = instantiate_node(SyntaxNode,input, index...(index + 1))
+             @index += 1
+           else
+             terminal_parse_failure('|')
+             r8 = nil
+           end
+           s7 << r8
+           if r8
+             r10 = _nt_weight
+             if r10
+               r9 = r10
+             else
+               r9 = instantiate_node(SyntaxNode,input, index...index)
+             end
+             s7 << r9
+             if r9
+               r11 = _nt_sentence
+               s7 << r11
+             end
+           end
+           if s7.last
+             r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+             r7.extend(Choice1)
+           else
+             @index = i7
+             r7 = nil
+           end
+           if r7
+             s6 << r7
+           else
+             break
+           end
+         end
+         r6 = instantiate_node(SyntaxNode,input, i6...index, s6)
+         s0 << r6
+         if r6
+           if has_terminal?('}', false, index)
+             r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+             @index += 1
+           else
+             terminal_parse_failure('}')
+             r12 = nil
+           end
+           s0 << r12
+         end
+       end
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Choice2)
+       r0.extend(Choice3)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:choice][start_index] = r0
+
+     r0
+   end
+
+   module Weight0
+     def w
+       elements[0]
+     end
+
+   end
+
+   module Weight1
+				def value
+					w.text_value.to_i
+				end
+   end
+
+   def _nt_weight
+     start_index = index
+     if node_cache[:weight].has_key?(index)
+       cached = node_cache[:weight][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     i0, s0 = index, []
+     s1, i1 = [], index
+     loop do
+       if has_terminal?('\G[0-9]', true, index)
+         r2 = true
+         @index += 1
+       else
+         r2 = nil
+       end
+       if r2
+         s1 << r2
+       else
+         break
+       end
+     end
+     if s1.empty?
+       @index = i1
+       r1 = nil
+     else
+       r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+     end
+     s0 << r1
+     if r1
+       if has_terminal?(':', false, index)
+         r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+         @index += 1
+       else
+         terminal_parse_failure(':')
+         r3 = nil
+       end
+       s0 << r3
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Weight0)
+       r0.extend(Weight1)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:weight][start_index] = r0
+
+     r0
+   end
+
+   module Substitution0
+   end
+
+   module Substitution1
+   end
+
+   module Substitution2
+     def w1
+       elements[2]
+     end
+
+     def name
+       elements[3]
+     end
+
+     def w2
+       elements[4]
+     end
+
+     def options
+       elements[5]
+     end
+
+     def w3
+       elements[6]
+     end
+
+   end
+
+   module Substitution3
+				def compose(kb = nil)
+					if kb
+						result = kb.find(name.text_value).confabulate
+						if options.text_value =~ /p/
+							result = result.en.plural
+						elsif options.text_value =~ /c/
+							result[0] = result[0].upcase if result[0]
+						end
+						result
+					else
+						""
+					end
+				end
+   end
+
+   def _nt_substitution
+     start_index = index
+     if node_cache[:substitution].has_key?(index)
+       cached = node_cache[:substitution][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     i0, s0 = index, []
+     i1 = index
+     if has_terminal?('\\\\', false, index)
+       r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
+       @index += 2
+     else
+       terminal_parse_failure('\\\\')
+       r2 = nil
+     end
+     if r2
+       r1 = nil
+     else
+       @index = i1
+       r1 = instantiate_node(SyntaxNode,input, index...index)
+     end
+     s0 << r1
+     if r1
+       if has_terminal?('[', false, index)
+         r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+         @index += 1
+       else
+         terminal_parse_failure('[')
+         r3 = nil
+       end
+       s0 << r3
+       if r3
+         r4 = _nt_w
+         s0 << r4
+         if r4
+           i5, s5 = index, []
+           if has_terminal?('\G[a-zA-Z]', true, index)
+             r6 = true
+             @index += 1
+           else
+             r6 = nil
+           end
+           s5 << r6
+           if r6
+             s7, i7 = [], index
+             loop do
+               if has_terminal?('\G[a-zA-Z_0-9-]', true, index)
+                 r8 = true
+                 @index += 1
+               else
+                 r8 = nil
+               end
+               if r8
+                 s7 << r8
+               else
+                 break
+               end
+             end
+             r7 = instantiate_node(SyntaxNode,input, i7...index, s7)
+             s5 << r7
+           end
+           if s5.last
+             r5 = instantiate_node(SyntaxNode,input, i5...index, s5)
+             r5.extend(Substitution0)
+           else
+             @index = i5
+             r5 = nil
+           end
+           s0 << r5
+           if r5
+             r9 = _nt_w
+             s0 << r9
+             if r9
+               i11, s11 = index, []
+               if has_terminal?(":", false, index)
+                 r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                 @index += 1
+               else
+                 terminal_parse_failure(":")
+                 r12 = nil
+               end
+               s11 << r12
+               if r12
+                 s13, i13 = [], index
+                 loop do
+                   if has_terminal?('\G[a-zA-Z]', true, index)
+                     r14 = true
+                     @index += 1
+                   else
+                     r14 = nil
+                   end
+                   if r14
+                     s13 << r14
+                   else
+                     break
+                   end
+                 end
+                 if s13.empty?
+                   @index = i13
+                   r13 = nil
+                 else
+                   r13 = instantiate_node(SyntaxNode,input, i13...index, s13)
+                 end
+                 s11 << r13
+               end
+               if s11.last
+                 r11 = instantiate_node(SyntaxNode,input, i11...index, s11)
+                 r11.extend(Substitution1)
+               else
+                 @index = i11
+                 r11 = nil
+               end
+               if r11
+                 r10 = r11
+               else
+                 r10 = instantiate_node(SyntaxNode,input, index...index)
+               end
+               s0 << r10
+               if r10
+                 r15 = _nt_w
+                 s0 << r15
+                 if r15
+                   if has_terminal?(']', false, index)
+                     r16 = instantiate_node(SyntaxNode,input, index...(index + 1))
+                     @index += 1
+                   else
+                     terminal_parse_failure(']')
+                     r16 = nil
+                   end
+                   s0 << r16
+                 end
+               end
+             end
+           end
+         end
+       end
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Substitution2)
+       r0.extend(Substitution3)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:substitution][start_index] = r0
+
+     r0
+   end
+
+   module W0
+				def compose(kb = nil)
+					text_value
+				end
+   end
+
+   def _nt_w
+     start_index = index
+     if node_cache[:w].has_key?(index)
+       cached = node_cache[:w][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     s0, i0 = [], index
+     loop do
+       if has_terminal?('\G[ \\t]', true, index)
+         r1 = true
+         @index += 1
+       else
+         r1 = nil
+       end
+       if r1
+         s0 << r1
+       else
+         break
+       end
+     end
+     r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+     r0.extend(W0)
+
+     node_cache[:w][start_index] = r0
+
+     r0
+   end
+
+   module EscapedChar0
+   end
+
+   module EscapedChar1
+				def compose(kb = nil)
+					text_value
+				end
+   end
+
+   def _nt_escaped_char
+     start_index = index
+     if node_cache[:escaped_char].has_key?(index)
+       cached = node_cache[:escaped_char][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     i0, s0 = index, []
+     if has_terminal?('\\', false, index)
+       r1 = instantiate_node(SyntaxNode,input, index...(index + 1))
+       @index += 1
+     else
+       terminal_parse_failure('\\')
+       r1 = nil
+     end
+     s0 << r1
+     if r1
+       if index < input_length
+         r2 = instantiate_node(SyntaxNode,input, index...(index + 1))
+         @index += 1
+       else
+         terminal_parse_failure("any character")
+         r2 = nil
+       end
+       s0 << r2
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(EscapedChar0)
+       r0.extend(EscapedChar1)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:escaped_char][start_index] = r0
+
+     r0
+   end
+
+   module Words0
+				def compose(kb = nil)
+					text_value
+				end
+   end
+
+   def _nt_words
+     start_index = index
+     if node_cache[:words].has_key?(index)
+       cached = node_cache[:words][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     s0, i0 = [], index
+     loop do
+       if has_terminal?('\G[^\\[{}\\|\\\\]', true, index)
+         r1 = true
+         @index += 1
+       else
+         r1 = nil
+       end
+       if r1
+         s0 << r1
+       else
+         break
+       end
+     end
+     if s0.empty?
+       @index = i0
+       r0 = nil
+     else
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Words0)
+     end
+
+     node_cache[:words][start_index] = r0
+
+     r0
+   end
+
+   module Char0
+   end
+
+   module Char1
+				def compose(kb = nil)
+					text_value
+				end
+   end
+
+   def _nt_char
+     start_index = index
+     if node_cache[:char].has_key?(index)
+       cached = node_cache[:char][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     i0, s0 = index, []
+     i1 = index
+     if has_terminal?('\\\\', false, index)
+       r2 = instantiate_node(SyntaxNode,input, index...(index + 2))
+       @index += 2
+     else
+       terminal_parse_failure('\\\\')
+       r2 = nil
+     end
+     if r2
+       r1 = nil
+     else
+       @index = i1
+       r1 = instantiate_node(SyntaxNode,input, index...index)
+     end
+     s0 << r1
+     if r1
+       if index < input_length
+         r3 = instantiate_node(SyntaxNode,input, index...(index + 1))
+         @index += 1
+       else
+         terminal_parse_failure("any character")
+         r3 = nil
+       end
+       s0 << r3
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Char0)
+       r0.extend(Char1)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:char][start_index] = r0
+
+     r0
+   end
+
+ end
+
+ class ConfabulatorLanguageParser < Treetop::Runtime::CompiledParser
+   include ConfabulatorLanguage
+ end
+
+end

data/lib/confabulator/parser.rb

@@ -0,0 +1,31 @@
+require "rubygems"
+require "linguistics"
+Linguistics::use( :en )
+
+module Confabulator
+  class Parser
+    attr_accessor :confabulation, :kb
+    
+    def initialize(str, opts = {})
+      self.confabulation = str
+      self.kb = opts[:knowledge]
+    end
+    
+    def confabulate
+      if parser
+        parser.compose(kb).squeeze(" ")
+      else
+        ""
+      end
+    end
+    
+    def parser
+      if !@parsed # this caches even a nil result
+        @cached_parser = ConfabulatorLanguageParser.new.parse(confabulation)
+        @parsed = true
+      end
+
+      @cached_parser
+    end
+  end
+end

data/lib/confabulator/version.rb

@@ -0,0 +1,3 @@
+module Confabulator
+  VERSION = "0.0.1"
+end

data/spec/confabulator_spec.rb

@@ -0,0 +1,89 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Confabulator do
+  describe "choice blocks" do
+    it "should work" do
+      100.times.map {
+        Confabulator::Parser.new("{Choice one|Choice two} and stuff").confabulate
+      }.uniq.sort.should == [
+        "Choice one and stuff",
+        "Choice two and stuff"
+      ]
+    end
+
+    it "should be recursive" do
+      100.times.map {
+        Confabulator::Parser.new("{Choice {1|2}|Choice 3} and stuff").confabulate
+      }.uniq.sort.should == [
+        "Choice 1 and stuff",
+        "Choice 2 and stuff",
+        "Choice 3 and stuff"
+      ]
+    end
+    
+    it "should allow differential weighting" do
+      one = two = 0
+      500.times do
+        case Confabulator::Parser.new("{5:Choice 1|Choice 2} and stuff").confabulate
+          when "Choice 1 and stuff"
+            one += 1
+          when "Choice 2 and stuff"
+            two += 1
+        end
+      end
+      one.should > two * 3
+      one.should < two * 7
+    end
+  end
+  
+  describe "substitutions" do
+    it "should use the knowledge base" do
+      knowledge = Confabulator::Knowledge.new
+      knowledge.add "world", "there"
+      Confabulator::Parser.new("Hello, [world]!", :knowledge => knowledge).confabulate.should == "Hello, there!"
+    end
+    
+    it "should return an empty string if it cannot be found" do
+      Confabulator::Parser.new("Hello, [world]!").confabulate.should == "Hello, !"
+    end
+
+    it "should work recursively" do
+      k = Confabulator::Knowledge.new
+      k.add "expand" => "is [recursive]", 
+            "recursive" => "pretty cool"
+      k.confabulate("Hello, this [expand]!").should == "Hello, this is pretty cool!"
+    end
+    
+    it "should work with choices too" do
+      k = Confabulator::Knowledge.new
+      k.add "expand" => "is {[recursive]|not recursive}", "recursive" => "pretty cool"
+      100.times.map {
+        Confabulator::Parser.new("Hello, this [expand]!", :knowledge => k).confabulate
+      }.uniq.sort.should == [
+        "Hello, this is not recursive!",
+        "Hello, this is pretty cool!"
+      ]
+    end
+    
+    it "should be able to capitalize" do
+      k = Confabulator::Knowledge.new
+      k.add "blah" => "world foo"
+      k.confabulate("Hello. [blah:c]!").should == "Hello. World foo!"
+    end
+
+    it "should be able to pluralize" do
+      k = Confabulator::Knowledge.new
+      k.add "blah" => "ancient dog"
+      k.confabulate("Many [blah:p]!").should == "Many ancient dogs!"
+    end
+  end
+  
+  describe "general behavior" do
+    it "should remove repeated spaces" do
+      k = Confabulator::Knowledge.new
+      k.add "expand" => "  is {[recursive]|  not recursive}", "recursive" => "pretty   cool "
+      Confabulator::Parser.new("Hello, this  [expand]!", :knowledge => k).confabulate.should_not =~ /  /
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format s -c
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'rspec'
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'confabulator'
+
+RSpec.configure do |c|
+end

data/src/confabulator_language.treetop

@@ -0,0 +1,82 @@
+module Confabulator
+	grammar ConfabulatorLanguage
+		 rule sentence
+		 	(substitution / choice / escaped_char / words)+ {
+				def compose(kb = nil)
+					elements.map {|e| e.compose(kb) }.join
+				end
+			}
+		 end
+	
+		rule choice
+	   	'{' first_sentence:(weight:weight? sentence) rest_sentences:('|' weight:weight? sentence)* '}' {
+				def compose(kb = nil)
+					elems = []
+					(first_sentence.weight.empty? ? 1 : first_sentence.weight.value).times { elems << first_sentence.sentence }
+					rest_sentences.elements.each do |s|
+						(s.weight.empty? ? 1 : s.weight.value).times { elems << s.sentence }
+					end
+					elems[elems.length * rand].compose(kb)
+				end
+			}
+		end
+		
+		rule weight
+			w:([0-9]+) ':' {
+				def value
+					w.text_value.to_i
+				end
+			}
+		end
+		
+		rule substitution
+			!'\\\\' '[' w name:( [a-zA-Z] [a-zA-Z_0-9-]* ) w options:(":" [a-zA-Z]+)? w ']' {
+				def compose(kb = nil)
+					if kb
+						result = kb.find(name.text_value).confabulate
+						if options.text_value =~ /p/
+							result = result.en.plural
+						elsif options.text_value =~ /c/
+							result[0] = result[0].upcase if result[0]
+						end
+						result
+					else
+						""
+					end
+				end
+			}
+		end
+	
+		rule w
+			[ \t]* {
+				def compose(kb = nil)
+					text_value
+				end
+			}
+		end
+	
+		rule escaped_char
+			'\\' . {
+				def compose(kb = nil)
+					text_value
+				end
+			}
+		end
+	
+		rule words
+			[^\[{}\|\\]+ {
+				def compose(kb = nil)
+					text_value
+				end
+			}
+		end
+	
+		rule char
+			!'\\\\' . {
+				def compose(kb = nil)
+					text_value
+				end
+			}
+		end
+	end
+end

data/test_grammer.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+$: << File.expand_path(File.join(File.dirname(__FILE__), "lib"))
+require 'confabulator'
+
+kb = Confabulator::Knowledge.new
+kb.add "ok" => "{ok|sure|sure thing|no problem|gotcha}",
+       "time" => "{current time|time}"
+puts kb.confabulate("[ok], the [time] is #{Time.now}")

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: confabulator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Cantino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70312387498520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70312387498520
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: &70312387498100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70312387498100
+- !ruby/object:Gem::Dependency
+  name: linguistics
+  requirement: &70312387497680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70312387497680
+description: ''
+email:
+- andrew@iterationlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.markdown
+- Rakefile
+- confabulator.gemspec
+- lib/confabulator.rb
+- lib/confabulator/knowledge.rb
+- lib/confabulator/language.rb
+- lib/confabulator/parser.rb
+- lib/confabulator/version.rb
+- spec/confabulator_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- src/confabulator_language.treetop
+- test_grammer.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: confabulator
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Ruby generative grammer for conversational text
+test_files:
+- spec/confabulator_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb