confabulator 0.0.2 → 0.0.3

data/README.markdown

@@ -1,6 +1,10 @@
 # Confabulator
 
-A recursive Ruby tempting language for the procedural generation of random sentences.
+A recursive Ruby templating language for the procedural generation of random sentences.
+
+## Why do I care?
+
+Perhaps you want to generate emails, text messages, or webpages that are all readable, but have different wording.  Perhaps you're writing a game and want to vary character dialog.  Perhaps you don't need a reason.
 
 ## Install
 
@@ -20,12 +24,16 @@ Choice blocks let the parser make a random choice.
     Choice two and stuff
     ...
 
-Recursion is fine (just try to avoid loops):
+Choices inside of choices (ad infinitum) are fine:
 
-    > 5.times { puts Confabulator::Parser.new("{Choice {1|2}|Choice 3} and stuff").confabulate }
-    Choice 3 and stuff
-    Choice 1 and stuff
-    Choice 2 and stuff
+    > 5.times { puts Confabulator::Parser.new("This is {an example|a {good|great|mediocre} demonstration}").confabulate }
+    This is a great demonstration
+    This is a mediocre demonstration
+    This is an example
+    This is a good demonstration
+    This is an example
+    This is an example
+    This is a good demonstration
     ...
 
 You can differentially weight the options: {5:This is 5 times more likely|than this}
@@ -35,19 +43,22 @@ You can differentially weight the options: {5:This is 5 times more likely|than t
 Substitutions let you re-use common templates.
 
     > knowledge = Confabulator::Knowledge.new
-    > knowledge.add "world", "there" # a hash is also acceptable
-    > Confabulator::Parser.new("Hello, [world]!", :knowledge => knowledge).confabulate
+    > knowledge.add "friend", "{friend|world|there}" # a hash is also acceptable
+    > Confabulator::Parser.new("Hello, [friend]!", :knowledge => knowledge).confabulate
     => "Hello, there!"
+    > Confabulator::Parser.new("Hello, [friend]!", :knowledge => knowledge).confabulate
+    => "Hello, world!"
+    ...
 
-Equivalently:
+Equivalently, as a helper on the Knowledge object:
 
-    > knowledge.confabulate("Hello, [world]!")
+    > knowledge.confabulate("Hello, [friend]!")
     => "Hello, there!"
 
 You can ask a substitution to be capitalized:
 
-    > knowledge.confabulate("Hello, [world:c]!")
-    => "Hello, There!"
+    > knowledge.confabulate("Hello, [friend:c]!")
+    => "Hello, World!"
 
 Or pluralized:
 
@@ -55,7 +66,7 @@ Or pluralized:
     > knowledge.confabulate("Hello, [dude:p]!")
     => "Hello, friends!"
 		
-Substitutions can contain other substitutions in choice nodes inside of substitutions, etc., ad infinitum.
+Substitutions can contain other substitutions inside of choice nodes inside of other substitutions, etc., ad infinitum.  Just try to avoid infinite loops!
 
 ### Escaping
 
@@ -76,6 +87,15 @@ Sometimes you want to insert user generated content without having to escape eve
 
 At the moment, sequences of more than one backtick are never allowed inside of a protected region.
 
+## Next Steps
+
+Here are some things that could be added to this library:
+
+ * Depth limits
+ * Better escaping
+ * Learning through back propagation of a reward signal and optimization of the choice nodes to make the rewarded or penalized outcome more or less likely, respectively.
+ * Whatever you want!
+
 ## Helping out
 
-Fork, write specs, add a feature, send me a pull request!
+Fork, write specs, add a feature, write documentation, send me a pull request!

data/lib/confabulator/language.rb

@@ -10,9 +10,13 @@ module Confabulator
    end
 
    module Sentence0
-				def compose(kb = nil)
-					elements.map {|e| e.compose(kb) }.join
+				def confabulate(kb = nil)
+					elements.map {|e| e.confabulate(kb) }.join
 				end
+				
+				def tree(kb = nil)
+				  elements.map { |e| e.tree(kb) }
+			  end
    end
 
    def _nt_sentence
@@ -90,7 +94,7 @@ module Confabulator
        elements[1]
      end
 
-     def sentence
+     def sentence_or_empty
        elements[2]
      end
    end
@@ -107,13 +111,23 @@ module Confabulator
    end
 
    module Choice3
-				def compose(kb = nil)
-					elems = []
-					(first_sentence.weight.empty? ? 1 : first_sentence.weight.value).times { elems << first_sentence.sentence }
+	   	  def choices(kb, no_weighting = false)
+	   	    elems = []
+					((no_weighting || 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 }
+						((no_weighting || s.weight.empty?) ? 1 : s.weight.value).times { elems << s.sentence_or_empty }
 					end
-					elems[elems.length * rand].compose(kb)
+					elems
+				end
+
+				def confabulate(kb = nil)
+				  elems = choices(kb)
+				  elems[elems.length * rand].confabulate(kb)
+				end
+
+				def tree(kb = nil)
+				  elems = choices(kb, true)
+				  { :choices => elems.map {|e| Confabulator::Parser.remove_singleton_arrays(e.tree(kb)) } }
 				end
    end
 
@@ -179,7 +193,19 @@ module Confabulator
              end
              s7 << r9
              if r9
-               r11 = _nt_sentence
+               i11 = index
+               r12 = _nt_sentence
+               if r12
+                 r11 = r12
+               else
+                 r13 = _nt_empty
+                 if r13
+                   r11 = r13
+                 else
+                   @index = i11
+                   r11 = nil
+                 end
+               end
                s7 << r11
              end
            end
@@ -200,13 +226,13 @@ module Confabulator
          s0 << r6
          if r6
            if has_terminal?('}', false, index)
-             r12 = instantiate_node(SyntaxNode,input, index...(index + 1))
+             r14 = instantiate_node(SyntaxNode,input, index...(index + 1))
              @index += 1
            else
              terminal_parse_failure('}')
-             r12 = nil
+             r14 = nil
            end
-           s0 << r12
+           s0 << r14
          end
        end
      end
@@ -224,6 +250,41 @@ module Confabulator
      r0
    end
 
+   module Empty0
+		    def confabulate(kb = nil)
+		      ''
+		    end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
+   end
+
+   def _nt_empty
+     start_index = index
+     if node_cache[:empty].has_key?(index)
+       cached = node_cache[:empty][index]
+       if cached
+         cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+         @index = cached.interval.end
+       end
+       return cached
+     end
+
+     if has_terminal?('', false, index)
+       r0 = instantiate_node(SyntaxNode,input, index...(index + 0))
+       r0.extend(Empty0)
+       @index += 0
+     else
+       terminal_parse_failure('')
+       r0 = nil
+     end
+
+     node_cache[:empty][start_index] = r0
+
+     r0
+   end
+
    module Weight0
      def w
        elements[0]
@@ -305,11 +366,15 @@ module Confabulator
    end
 
    module Protected2
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					words.elements.map { |element|
 						element.text_value == "\\`" ? "`" : element.text_value
 					}.join
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
    end
 
    def _nt_protected
@@ -445,12 +510,13 @@ module Confabulator
    end
 
    module Substitution3
-				def compose(kb = nil)
+				def confabulate(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/
+						end
+						if options.text_value =~ /c/
 							result[0] = result[0].upcase if result[0]
 						end
 						result
@@ -458,6 +524,21 @@ module Confabulator
 						""
 					end
 				end
+
+				def tree(kb = nil)
+  				if kb
+  					results = kb.find(name.text_value).tree
+  					if options.text_value =~ /p/
+  					  results = { :pluralize => results }
+  					end
+  					if options.text_value =~ /c/
+  					  results = { :capitalize => results }
+  					end
+  					results
+  				else
+  					""
+  				end
+				end
    end
 
    def _nt_substitution
@@ -617,9 +698,13 @@ module Confabulator
    end
 
    module W0
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					text_value
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
    end
 
    def _nt_w
@@ -662,9 +747,13 @@ module Confabulator
    end
 
    module EscapedChar1
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					character.text_value
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
    end
 
    def _nt_escaped_char
@@ -712,9 +801,13 @@ module Confabulator
    end
 
    module Words0
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					text_value
 				end
+				
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
    end
 
    def _nt_words

data/lib/confabulator/parser.rb

@@ -14,7 +14,7 @@ module Confabulator
     
     def confabulate
       if parser
-        result = parser.compose(kb)
+        result = parser.confabulate(kb)
         result.gsub!(REMOVE_SPACES, '\1 \2') while result =~ REMOVE_SPACES
         result
       else
@@ -22,6 +22,14 @@ module Confabulator
       end
     end
     
+    def all_confabulations
+      self.class.expand_tree(tree)
+    end
+
+    def tree
+      parser ? parser.tree(kb) : []
+    end
+    
     def parser
       if !@parsed # this caches even a nil result
         @cached_parser = ConfabulatorLanguageParser.new.parse(confabulation)
@@ -30,5 +38,48 @@ module Confabulator
 
       @cached_parser
     end
+    
+    def self.expand_tree(s, combinations = [], x = nil, *a)
+      if !s.is_a?(String) && combinations == []
+        expand_tree("", combinations, *s)
+      else
+        case x
+          when Hash
+            if x[:choices]
+              x[:choices].each {|c| expand_tree(s, combinations, c, *a)}
+            elsif x[:pluralize]
+              tree_below_here = expand_tree("", [], x[:pluralize]).map { |r| r.en.plural }
+              expand_tree(s, combinations, { :choices => tree_below_here })
+            elsif x[:capitalize]
+              tree_below_here = expand_tree("", [], x[:capitalize])
+              tree_below_here.each { |r| r[0] = r[0].upcase if r[0] }
+              expand_tree(s, combinations, { :choices => tree_below_here })
+            else
+              raise "Hash found without :choices, :pluralize, or :capitalize in it: #{x.inspect}"
+            end
+          when Array
+            expand_tree(s, combinations, *x, *a)
+          when String
+            expand_tree(s+x, combinations, *a)
+          when nil
+            combinations << s
+          else
+            raise "Non String, Array, Hash, or nil value in expand_tree: #{x.inspect}"
+        end
+        combinations
+      end
+    end
+
+    def self.remove_singleton_arrays(arr)
+      if arr.is_a?(Array)
+        if arr.length == 1
+          remove_singleton_arrays(arr.first)
+        else
+          arr.map { |a| remove_singleton_arrays(a) }
+        end
+      else
+        arr
+      end
+    end
   end
 end

data/lib/confabulator/version.rb

@@ -1,3 +1,3 @@
 module Confabulator
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/confabulator_spec.rb

@@ -11,7 +11,7 @@ describe Confabulator do
         "Choice two and stuff"
       ]
     end
-
+    
     it "should be recursive" do
       100.times.map {
         Confabulator::Parser.new("{Choice {1|2}|Choice 3} and stuff").confabulate
@@ -35,6 +35,16 @@ describe Confabulator do
       one.should > two * 3
       one.should < two * 7
     end
+    
+    it "should allow an empty node" do
+      100.times.map {
+        Confabulator::Parser.new("{foo|}bar").confabulate
+      }.uniq.sort.should == [ "bar", "foobar" ]
+
+      100.times.map {
+        Confabulator::Parser.new("{a|b|c|}x").confabulate
+      }.uniq.sort.should == [ "ax", "bx", "cx", "x" ]
+    end
   end
   
   describe "substitutions" do
@@ -47,7 +57,7 @@ describe Confabulator do
     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]", 
@@ -71,12 +81,18 @@ describe Confabulator do
       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
+
+    it "should be able to pluralize and capitalize at the same time" do
+      k = Confabulator::Knowledge.new
+      k.add "blah" => "ancient dog"
+      k.confabulate("Many [blah:pc]!").should == "Many Ancient dogs!"
+    end
   end
   
   describe "general behavior" do
@@ -84,7 +100,7 @@ describe Confabulator do
       @k = Confabulator::Knowledge.new
       @k.add "expand" => "  is {[recursive]|  not recursive}", "recursive" => "pretty   cool "
     end
-
+  
     it "should remove repeated spaces between words" do
       @k.confabulate("Hello, this  [expand]!").should_not =~ /  /
     end
@@ -109,4 +125,28 @@ describe Confabulator do
       Confabulator::Parser.new("Hi \\[foo]\\{bar\\|foo\\}\\`baz\\` and stuff").confabulate.should == "Hi [foo]{bar|foo}`baz` and stuff"
     end
   end
+  
+  describe "listing all possible confabulations" do
+    it "should be able to enumerate all possible onfabulations" do
+      k = Confabulator::Knowledge.new
+      k.add "friend" => "{friend|pal}"
+      k.add "from" => "your [friend:c]"
+      k.add "said" => "says"
+      all = Confabulator::Parser.new("{He{ll}o|Hi} {worl{d|}|there}, [said] [from:cp]", :knowledge => k).all_confabulations
+      all.should =~ [
+        "Hello world, says Your Friends", 
+        "Hello worl, says Your Friends", 
+        "Hello there, says Your Friends", 
+        "Hi world, says Your Friends", 
+        "Hi worl, says Your Friends", 
+        "Hi there, says Your Friends",
+        "Hello world, says Your Pals", 
+        "Hello worl, says Your Pals", 
+        "Hello there, says Your Pals", 
+        "Hi world, says Your Pals", 
+        "Hi worl, says Your Pals", 
+        "Hi there, says Your Pals"
+      ]
+    end
+  end
 end

data/src/confabulator_language.treetop

@@ -2,25 +2,51 @@ module Confabulator
 	grammar ConfabulatorLanguage
 		 rule sentence
 		 	(protected / substitution / choice / escaped_char / words)+ {
-				def compose(kb = nil)
-					elements.map {|e| e.compose(kb) }.join
+				def confabulate(kb = nil)
+					elements.map {|e| e.confabulate(kb) }.join
 				end
+				
+				def tree(kb = nil)
+				  elements.map { |e| e.tree(kb) }
+			  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 }
+	   	'{' first_sentence:(weight:weight? sentence) rest_sentences:('|' weight:weight? sentence_or_empty:(sentence / empty))* '}' {
+	   	  def choices(kb, no_weighting = false)
+	   	    elems = []
+					((no_weighting || 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 }
+						((no_weighting || s.weight.empty?) ? 1 : s.weight.value).times { elems << s.sentence_or_empty }
 					end
-					elems[elems.length * rand].compose(kb)
+					elems
+				end
+
+				def confabulate(kb = nil)
+				  elems = choices(kb)
+				  elems[elems.length * rand].confabulate(kb)
+				end
+
+				def tree(kb = nil)
+				  elems = choices(kb, true)
+				  { :choices => elems.map {|e| Confabulator::Parser.remove_singleton_arrays(e.tree(kb)) } }
 				end
 			}
 		end
 		
+		rule empty
+		  '' {
+		    def confabulate(kb = nil)
+		      ''
+		    end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
+		  }
+	  end
+		
 		rule weight
 			w:([0-9]+) ':' {
 				def value
@@ -31,22 +57,27 @@ module Confabulator
 		
 		rule protected
 			"``" words:(("`" [^`]) / [^`])+ "``" {
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					words.elements.map { |element|
 						element.text_value == "\\`" ? "`" : element.text_value
 					}.join
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
 			}
 		end
 		
 		rule substitution
 			!'\\\\' '[' w name:( [a-zA-Z] [a-zA-Z_0-9-]* ) w options:(":" [a-zA-Z]+)? w ']' {
-				def compose(kb = nil)
+				def confabulate(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/
+						end
+						if options.text_value =~ /c/
 							result[0] = result[0].upcase if result[0]
 						end
 						result
@@ -54,30 +85,57 @@ module Confabulator
 						""
 					end
 				end
+
+				def tree(kb = nil)
+  				if kb
+  					results = kb.find(name.text_value).tree
+  					if options.text_value =~ /p/
+  					  results = { :pluralize => results }
+  					end
+  					if options.text_value =~ /c/
+  					  results = { :capitalize => results }
+  					end
+  					results
+  				else
+  					""
+  				end
+				end
 			}
 		end
 	
 		rule w
 			[ \t]* {
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					text_value
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
 			}
 		end
 	
 		rule escaped_char
 			'\\' character:. {
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					character.text_value
 				end
+
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
 			}
 		end
 	
 		rule words
 			[^\[{}`\|\\]+ {
-				def compose(kb = nil)
+				def confabulate(kb = nil)
 					text_value
 				end
+				
+				def tree(kb = nil)
+				  confabulate(kb)
+				end
 			}
 		end
 	end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: confabulator
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-07 00:00:00.000000000Z
+date: 2011-12-25 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70215715712220 !ruby/object:Gem::Requirement
+  requirement: &70350927242820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70215715712220
+  version_requirements: *70350927242820
 - !ruby/object:Gem::Dependency
   name: treetop
-  requirement: &70215715711800 !ruby/object:Gem::Requirement
+  requirement: &70350927242400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70215715711800
+  version_requirements: *70350927242400
 - !ruby/object:Gem::Dependency
   name: linguistics
-  requirement: &70215715711380 !ruby/object:Gem::Requirement
+  requirement: &70350927241980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70215715711380
+  version_requirements: *70350927241980
 description: ''
 email:
 - andrew@iterationlabs.com