confabulator 0.0.1 → 0.0.2

data/README.markdown

@@ -1,34 +1,81 @@
 # 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!"
+A recursive Ruby tempting language for the procedural generation of random sentences.
+
+## Install
+
+    gem install confabulator
+
+## Use
+
+    require 'confabulator'
+
+### Choice blocks
+
+Choice blocks let the parser make a random choice.
+
+    > 5.times { puts Confabulator::Parser.new("{Choice one|Choice two} and stuff").confabulate }
+    Choice two and stuff
+    Choice one and stuff
+    Choice two and stuff
+    ...
+
+Recursion is fine (just try to avoid loops):
+
+    > 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
+    ...
+
+You can differentially weight the options: {5:This is 5 times more likely|than this}
+
+### Substitutions
+
+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
+    => "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!"
+		
+Substitutions can contain other substitutions in choice nodes inside of substitutions, etc., ad infinitum.
+
+### Escaping
+
+You must escape the special characters {, [, `, and | with backslashes:
+
+    > knowledge.add "dude" => "friend"
+    > knowledge.confabulate("Hello, \\{friend\\|something\\} \\`\\`stuff\\`\\` \\[dude:p]!")
+    => "Hello, {friend|something}  ``stuff`` [dude:p]!!"
+
+### Protected regions
+
+Sometimes you want to insert user generated content without having to escape every {, [, `, and |.  For this you use protected regions.
+
+    > knowledge.add "dude" => "friend"
+    > user_content = "protect regions [and stuff] with double backticks (`)!"
+    > knowledge.confabulate("Hello, ``#{user_content}``")
+    => "Hello, protect regions [and stuff] with double backticks (`)!"
+
+At the moment, sequences of more than one backtick are never allowed inside of a protected region.
+
+## Helping out
+
+Fork, write specs, add a feature, send me a pull request!

data/lib/confabulator/language.rb

@@ -29,24 +29,29 @@ module Confabulator
      s0, i0 = [], index
      loop do
        i1 = index
-       r2 = _nt_substitution
+       r2 = _nt_protected
        if r2
          r1 = r2
        else
-         r3 = _nt_choice
+         r3 = _nt_substitution
          if r3
            r1 = r3
          else
-           r4 = _nt_escaped_char
+           r4 = _nt_choice
            if r4
              r1 = r4
            else
-             r5 = _nt_words
+             r5 = _nt_escaped_char
              if r5
                r1 = r5
              else
-               @index = i1
-               r1 = nil
+               r6 = _nt_words
+               if r6
+                 r1 = r6
+               else
+                 @index = i1
+                 r1 = nil
+               end
              end
            end
          end
@@ -289,6 +294,127 @@ module Confabulator
      r0
    end
 
+   module Protected0
+   end
+
+   module Protected1
+     def words
+       elements[1]
+     end
+
+   end
+
+   module Protected2
+				def compose(kb = nil)
+					words.elements.map { |element|
+						element.text_value == "\\`" ? "`" : element.text_value
+					}.join
+				end
+   end
+
+   def _nt_protected
+     start_index = index
+     if node_cache[:protected].has_key?(index)
+       cached = node_cache[:protected][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 + 2))
+       @index += 2
+     else
+       terminal_parse_failure("``")
+       r1 = nil
+     end
+     s0 << r1
+     if r1
+       s2, i2 = [], index
+       loop do
+         i3 = index
+         i4, s4 = index, []
+         if has_terminal?("`", false, index)
+           r5 = instantiate_node(SyntaxNode,input, index...(index + 1))
+           @index += 1
+         else
+           terminal_parse_failure("`")
+           r5 = nil
+         end
+         s4 << r5
+         if r5
+           if has_terminal?('\G[^`]', true, index)
+             r6 = true
+             @index += 1
+           else
+             r6 = nil
+           end
+           s4 << r6
+         end
+         if s4.last
+           r4 = instantiate_node(SyntaxNode,input, i4...index, s4)
+           r4.extend(Protected0)
+         else
+           @index = i4
+           r4 = nil
+         end
+         if r4
+           r3 = r4
+         else
+           if has_terminal?('\G[^`]', true, index)
+             r7 = true
+             @index += 1
+           else
+             r7 = nil
+           end
+           if r7
+             r3 = r7
+           else
+             @index = i3
+             r3 = nil
+           end
+         end
+         if r3
+           s2 << r3
+         else
+           break
+         end
+       end
+       if s2.empty?
+         @index = i2
+         r2 = nil
+       else
+         r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+       end
+       s0 << r2
+       if r2
+         if has_terminal?("``", false, index)
+           r8 = instantiate_node(SyntaxNode,input, index...(index + 2))
+           @index += 2
+         else
+           terminal_parse_failure("``")
+           r8 = nil
+         end
+         s0 << r8
+       end
+     end
+     if s0.last
+       r0 = instantiate_node(SyntaxNode,input, i0...index, s0)
+       r0.extend(Protected1)
+       r0.extend(Protected2)
+     else
+       @index = i0
+       r0 = nil
+     end
+
+     node_cache[:protected][start_index] = r0
+
+     r0
+   end
+
    module Substitution0
    end
 
@@ -530,11 +656,14 @@ module Confabulator
    end
 
    module EscapedChar0
+     def character
+       elements[1]
+     end
    end
 
    module EscapedChar1
 				def compose(kb = nil)
-					text_value
+					character.text_value
 				end
    end
 
@@ -601,7 +730,7 @@ module Confabulator
 
      s0, i0 = [], index
      loop do
-       if has_terminal?('\G[^\\[{}\\|\\\\]', true, index)
+       if has_terminal?('\G[^\\[{}`\\|\\\\]', true, index)
          r1 = true
          @index += 1
        else
@@ -626,66 +755,6 @@ module Confabulator
      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

data/lib/confabulator/parser.rb

@@ -4,6 +4,7 @@ Linguistics::use( :en )
 
 module Confabulator
   class Parser
+    REMOVE_SPACES = /(\S+) {2,}(\S+)/
     attr_accessor :confabulation, :kb
     
     def initialize(str, opts = {})
@@ -13,7 +14,9 @@ module Confabulator
     
     def confabulate
       if parser
-        parser.compose(kb).squeeze(" ")
+        result = parser.compose(kb)
+        result.gsub!(REMOVE_SPACES, '\1 \2') while result =~ REMOVE_SPACES
+        result
       else
         ""
       end

data/lib/confabulator/version.rb

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

data/spec/confabulator_spec.rb

@@ -80,10 +80,33 @@ describe Confabulator do
   end
   
   describe "general behavior" do
-    it "should remove repeated spaces" do
+    before 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
+    
+    it "should not remove leading spaces" do
+      @k.confabulate("  Hello, this  [expand]!").should =~ /^  Hello/
+      @k.confabulate("Foo    bar\n\n   baz").should == "Foo bar\n\n   baz"
+      @k.confabulate("List:\n  * foo\n  * bar baz     bing  blah").should == "List:\n  * foo\n  * bar baz bing blah"
+    end
+  end
+  
+  describe "protected regions" do
+    it "should not parse content inside of the region" 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 =~ /  /
+      k.add "expand" => "is ``{[recursive]|not recursive} single ticks (`) are ok``"
+      Confabulator::Parser.new("Hello, this [expand]!", :knowledge => k).confabulate.should == "Hello, this is {[recursive]|not recursive} single ticks (`) are ok!"
+    end
+  end
+  
+  describe "escaped characters" do
+    it "should show up as unescaped" do
+      Confabulator::Parser.new("Hi \\[foo]\\{bar\\|foo\\}\\`baz\\` and stuff").confabulate.should == "Hi [foo]{bar|foo}`baz` and stuff"
     end
   end
 end

data/src/confabulator_language.treetop

@@ -1,7 +1,7 @@
 module Confabulator
 	grammar ConfabulatorLanguage
 		 rule sentence
-		 	(substitution / choice / escaped_char / words)+ {
+		 	(protected / substitution / choice / escaped_char / words)+ {
 				def compose(kb = nil)
 					elements.map {|e| e.compose(kb) }.join
 				end
@@ -29,6 +29,16 @@ module Confabulator
 			}
 		end
 		
+		rule protected
+			"``" words:(("`" [^`]) / [^`])+ "``" {
+				def compose(kb = nil)
+					words.elements.map { |element|
+						element.text_value == "\\`" ? "`" : element.text_value
+					}.join
+				end
+			}
+		end
+		
 		rule substitution
 			!'\\\\' '[' w name:( [a-zA-Z] [a-zA-Z_0-9-]* ) w options:(":" [a-zA-Z]+)? w ']' {
 				def compose(kb = nil)
@@ -56,23 +66,15 @@ module Confabulator
 		end
 	
 		rule escaped_char
-			'\\' . {
+			'\\' character:. {
 				def compose(kb = nil)
-					text_value
+					character.text_value
 				end
 			}
 		end
 	
 		rule words
-			[^\[{}\|\\]+ {
-				def compose(kb = nil)
-					text_value
-				end
-			}
-		end
-	
-		rule char
-			!'\\\\' . {
+			[^\[{}`\|\\]+ {
 				def compose(kb = nil)
 					text_value
 				end

metadata

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