tracery 0.7.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ec31ad1ba40cf47f031700475119b6a474300f0
+  data.tar.gz: 5efe8a2fbe3751bbbdbef4545336b86b84063ae3
+SHA512:
+  metadata.gz: 4e9f09c43cbb638172af396452399c04cadb338a2414ea25625b995ddace2ceef805fce1a5595b56d13f2f19855850face9f0eef00ad8775adcf73e081a21e5b
+  data.tar.gz: be63c6d1c29154a101cd3a91cc838be9b9f4fbfd6031a0489ffd474851a39ff71b7eedbace080dc017a826ffa564e14d7f9c99b7597a331188de459a72210fa9

data/lib/mods-eng-basic.rb

@@ -0,0 +1,88 @@
+module Modifiers
+    def self.isVowel(c)
+        return ['a', 'e', 'i', 'o', 'u'].member?(c.downcase)
+    end
+
+    def self.pluralize(s)
+        case(s[-1])
+        when 's' then
+            return s + "es"
+        when 'h' then
+            return s + "es"
+        when 'x' then
+            return s + "es"
+        when 'y' then
+            if(!isVowel(s[-2])) then
+                return s[0...-1] + "ies"
+            else
+                return s + "s"
+            end
+        else
+            return s + "s"
+        end
+    end
+    
+    def self.baseEngModifiers
+        {
+            "replace" => lambda do |s, parameters|
+                return s.gsub(/#{Regexp.quote(parameters[0])}/, parameters[1])
+            end,
+
+            "capitalizeAll" => lambda do |s, parameters|
+                return s.gsub(/\w+/) {|word| word.capitalize}
+            end,
+            
+            "capitalize" => lambda do |s, parameters|
+                return s.capitalize
+            end,
+            
+            "a" => lambda do |s, parameters|
+                if(s.length > 0) then
+                    if(s =~ /^u((\wi)|(\W))/) then
+                        #catches "university" and "u-boat"
+                        return "a #{s}"
+                    end
+                    
+                    if(isVowel(s[0])) then
+                        return "an #{s}"
+                    end
+                end
+                
+                return "a #{s}"
+            end,
+
+            "firstS" => lambda do |s, parameters|
+                words = s.split(" ")
+                if(words.length > 0) then
+                    words[0] = pluralize words[0]
+                end
+                return words.join " "
+            end,
+            
+            "s" => lambda do |s, parameters|
+                return pluralize(s)
+            end,
+            
+            "ed" => lambda do |s, parameters|
+                case(s[-1])
+                    when 's' then
+                        return s + "ed"
+                    when 'e' then
+                        return s + "d"
+                    when 'h' then
+                        return s + "ed"
+                    when 'x' then
+                        return s + "ed"
+                    when 'y' then
+                        if(!isVowel(s[-2])) then
+                            return s[0...-1] + "ied"
+                        else
+                            return s + "d"
+                        end
+                    else
+                        return s + "ed"
+                end
+            end
+        }
+    end
+end

data/lib/tracery.rb

@@ -0,0 +1,637 @@
+require 'json'
+
+
+module Tracery
+    # Parses a plaintext rule in the tracery syntax
+    def createGrammar(raw)
+        return Grammar.new(raw)
+    end
+    
+    def parseTag(tagContents)
+        parsed = {
+                symbol: nil,
+                preactions: [],
+                postactions: [],
+                modifiers: []
+            }
+        
+        sections = parse(tagContents)[:sections]
+        symbolSection = nil;
+        sections.each do |section|
+            if(section[:type] == 0) then
+                if(symbolSection.nil?) then
+                    symbolSection = section[:raw]
+                else
+                    raise "multiple main sections in #{tagContents}"
+                end
+            else
+                parsed[:preactions].push(section)
+            end
+        end
+        
+        if(symbolSection.nil?) then
+            # raise "no main section in #{tagContents}"
+        else
+            
+            components = symbolSection.split(".");
+            parsed[:symbol] = components.first
+            parsed[:modifiers] = components.drop(1)
+        end
+
+        return parsed
+    end
+    
+    #TODO_: needs heavy refactoring -- no nesting in ruby (ie. move entire parser to another class w/ shared state)
+    def createSection(start, finish, type, results, lastEscapedChar, escapedSubstring, rule, errors)
+        if(finish - start < 1) then
+            if(type == 1) then
+                errors << "#{start}: empty tag"
+            else
+                if(type == 2) then
+                    errors << "#{start}: empty action"
+                end
+            end
+        end
+        rawSubstring = ""
+        if(!lastEscapedChar.nil?) then
+            rawSubstring = escapedSubstring + "\\" + rule[(lastEscapedChar+1)..-1]
+        else
+            rawSubstring = rule[start...finish]
+        end
+        
+        results[:sections] << {
+                type: type,
+                raw: rawSubstring
+            }
+    end
+    
+    def parse(rule)
+        depth = 0
+        inTag = false
+        results = {errors: [], sections: []}
+        escaped = false
+        
+        errors = []
+        start = 0
+        
+        escapedSubstring = ""
+        lastEscapedChar = nil
+
+        if(rule.nil?) then
+            sections = {errors: errors, sections: []}
+            return sections
+        end
+        
+        rule.each_char.with_index do |c, i|
+            if(!escaped) then
+                case(c)
+                    when '[' then
+                        # Enter a deeper bracketed section
+                        if(depth == 0 && !inTag) then
+                            if(start < i) then
+                                createSection(start, i, 0, results, lastEscapedChar, escapedSubstring, rule, errors)
+                                lastEscapedChar = nil
+                                escapedSubstring = ""
+                            end
+                            start = i + 1
+                        end
+                        depth += 1
+                    when ']' then
+                        depth -= 1
+                        # End a bracketed section
+                        if(depth == 0 && !inTag) then
+                            createSection(start, i, 2, results, lastEscapedChar, escapedSubstring, rule, errors)
+                            lastEscapedChar = nil
+                            escapedSubstring = ""
+                            start = i + 1
+                        end
+                    when '#' then
+                        # Hashtag
+                        #   ignore if not at depth 0, that means we are in a bracket
+                        if(depth == 0) then
+                            if(inTag) then
+                                createSection(start, i, 1, results, lastEscapedChar, escapedSubstring, rule, errors)
+                                lastEscapedChar = nil
+                                escapedSubstring = ""
+                                start = i + 1
+                            else
+                                if(start < i) then
+                                    createSection(start, i, 0, results, lastEscapedChar, escapedSubstring, rule, errors)
+                                    lastEscapedChar = nil
+                                    escapedSubstring = ""
+                                end
+                                start = i + 1
+                            end
+                            inTag = !inTag
+                        end
+                    when '\\' then
+                        escaped = true;
+                        escapedSubstring = escapedSubstring + rule[start...i];
+                        start = i + 1;
+                        lastEscapedChar = i;
+                end
+            else
+                escaped = false
+            end
+        end #each character in rule
+        
+        if(start < rule.length) then
+            createSection(start, rule.length, 0, results, lastEscapedChar, escapedSubstring, rule, errors)
+            lastEscapedChar = nil
+            escapedSubstring = ""
+        end
+        
+        errors << ("Unclosed tag") if inTag
+        errors << ("Too many [") if depth > 0
+        errors << ("Too many ]") if depth < 0
+
+        # Strip out empty plaintext sections
+        results[:sections].select! {|section| 
+            if(section[:type] == 0 && section[:raw].empty?) then
+                false
+            else
+                true
+            end
+        }
+        results[:errors] = errors;
+        return results
+    end
+end
+
+class TraceryNode
+    attr_accessor :grammar, :depth, :finishedText, :children, :errors
+    
+    include Tracery
+
+    def initialize(parent, childIndex, settings)
+        @errors = []
+        @children = []
+
+        if(settings[:raw].nil?) then
+            @errors << "Empty input for node"
+            settings[:raw] = ""
+        end
+        
+        # If the root node of an expansion, it will have the grammar passed as the 'parent'
+        # set the grammar from the 'parent', and set all other values for a root node
+        if(parent.is_a? Grammar)
+            @grammar = parent
+            @parent = nil
+            @depth = 0
+            @childIndex = 0
+        else
+            @grammar = parent.grammar
+            @parent = parent
+            @depth = parent.depth + 1
+            @childIndex = childIndex
+        end
+
+        @raw = settings[:raw]
+        @type = settings[:type]
+        @isExpanded = false
+        
+        @errors << "No grammar specified for this node #{self}" if (@grammar.nil?)
+    end
+    
+    def to_s
+        "Node('#{@raw}' #{@type} d:#{@depth})"
+    end
+    
+    def expandChildren(childRule, preventRecursion)
+        @finishedText = ""
+        @childRule = childRule
+        
+        if(!@childRule.nil?)
+            parsed = parse(childRule)
+            sections = parsed[:sections]
+
+            @errors.concat(parsed[:errors])
+
+            sections.each_with_index do |section, i|
+                child = TraceryNode.new(self, i, section)
+                if(!preventRecursion)
+                    child.expand(preventRecursion)
+                end
+                @finishedText += child.finishedText
+                @children << child
+            end
+        else
+            # In normal operation, this shouldn't ever happen
+            @errors << "No child rule provided, can't expand children"
+        end
+    end
+    
+    # Expand this rule (possibly creating children)
+    def expand(preventRecursion = false)
+        if(@isExpanded) then
+            @errors << "Already expanded #{self}"
+            return
+        end
+
+        @isExpanded = true
+        #this is no longer used
+        @expansionErrors = []
+                
+        # Types of nodes
+        # -1: raw, needs parsing
+        #  0: Plaintext
+        #  1: Tag ("#symbol.mod.mod2.mod3#" or "#[pushTarget:pushRule]symbol.mod#")
+        #  2: Action ("[pushTarget:pushRule], [pushTarget:POP]", more in the future)
+        
+        case(@type)
+            when -1 then
+                #raw rule
+                expandChildren(@raw, preventRecursion)
+            when 0 then
+                #plaintext, do nothing but copy text into finished text
+                @finishedText = @raw
+            when 1 then
+                #tag - Parse to find any actions, and figure out what the symbol is
+                @preactions = []
+                @postactions = []
+                parsed = parseTag(@raw)
+                @symbol = parsed[:symbol]
+                @modifiers = parsed[:modifiers]
+
+                # Create all the preactions from the raw syntax
+                @preactions = parsed[:preactions].map{|preaction|
+                    NodeAction.new(self, preaction[:raw])
+                }
+
+                # @postactions = parsed[:preactions].map{|postaction|
+                #     NodeAction.new(self, postaction.raw)
+                # }
+                
+                # Make undo actions for all preactions (pops for each push)
+                @postactions = @preactions.
+                                select{|preaction| preaction.type == 0 }.
+                                map{|preaction| preaction.createUndo() }
+                
+                @preactions.each { |preaction| preaction.activate }
+                
+                @finishedText = @raw
+
+                # Expand (passing the node, this allows tracking of recursion depth)
+                selectedRule = @grammar.selectRule(@symbol, self, @errors)
+
+                expandChildren(selectedRule, preventRecursion)
+                
+                # Apply modifiers
+                # TODO: Update parse function to not trigger on hashtags within parenthesis within tags,
+                # so that modifier parameters can contain tags "#story.replace(#protagonist#, #newCharacter#)#"
+                @modifiers.each{|modName|
+                    modParams = [];
+                    if (modName.include?("(")) then
+                        #match something like `modifier(param, param)`, capture name and params separately
+                        match = /([^\(]+)\(([^)]+)\)/.match(modName)
+                        if(!match.nil?) then
+                            modParams = match.captures[1].split(",")
+                            modName = match.captures[0]
+                        end
+                    end
+
+                    mod = @grammar.modifiers[modName]
+
+                    # Missing modifier?
+                    if(mod.nil?)
+                        @errors << "Missing modifier #{modName}"
+                        @finishedText += "((.#{modName}))"
+                    else
+                        @finishedText = mod.call(@finishedText, modParams)
+                    end
+                }
+                # perform post-actions
+                @postactions.each{|postaction| postaction.activate()}
+            when 2 then
+                # Just a bare action? Expand it!
+                @action = NodeAction.new(self, @raw)
+                @action.activate()
+                
+                # No visible text for an action
+                # TODO: some visible text for if there is a failure to perform the action?
+                @finishedText = ""
+        end
+    end
+
+    def allErrors
+        child_errors = @children.inject([]){|all, child| all.concat(child.allErrors)}
+        return child_errors.concat(@errors) 
+    end
+
+    def clearEscapeCharacters
+        @finishedText = @finishedText.gsub(/\\\\/, "DOUBLEBACKSLASH").gsub(/\\/, "").gsub(/DOUBLEBACKSLASH/, "\\")
+    end
+end
+
+# Types of actions:
+# 0 Push: [key:rule]
+# 1 Pop: [key:POP]
+# 2 function: [functionName(param0,param1)] (TODO!)
+class NodeAction
+    attr_accessor :node, :target, :type, :ruleNode
+    def initialize(node, raw)
+        # puts("No node for NodeAction") if(node.nil?)
+        # puts("No raw commands for NodeAction") if(raw.empty?)
+        
+        @node = node
+        
+        sections = raw.split(":")
+        @target = sections.first
+        if(sections.size == 1) then
+            # No colon? A function!
+            @type = 2
+        else
+            # Colon? It's either a push or a pop
+            @rule = sections[1] || ""
+            if(@rule == "POP")
+                @type = 1;
+            else
+                @type = 0;
+            end
+        end
+    end
+    
+    def activate
+        grammar = @node.grammar
+        case(@type)
+            when 0 then
+                # split into sections (the way to denote an array of rules)
+                ruleSections = @rule.split(",")
+                finishedRules = ruleSections.map{|ruleSection|
+                    n = TraceryNode.new(grammar, 0, {
+                            type: -1,
+                            raw: ruleSection
+                        })
+                    n.expand()
+                    n.finishedText
+                }
+                
+                # TODO: escape commas properly
+                grammar.pushRules(@target, finishedRules, self)
+                # puts("Push rules: #{@target} #{@ruleText}")
+            when 1 then
+                grammar.popRules(@target);
+            when 2 then
+                grammar.flatten(@target, true);
+        end
+    end
+
+    def createUndo
+        if(@type == 0) then
+            return NodeAction.new(@node, "#{@target}:POP")
+        end
+        # TODO Not sure how to make Undo actions for functions or POPs
+        return nil
+    end
+
+    def toText
+        case(@type)
+            when 0 then
+                return "#{@target}:#{@rule}"
+            when 1 then
+                return "#{@target}:POP"
+            when 2 then
+                return "((some function))"
+            else
+                return "((Unknown Action))"
+        end
+    end
+end
+
+# Sets of rules
+# (Can also contain conditional or fallback sets of rulesets)
+class RuleSet
+    def initialize(grammar, raw)
+        @raw = raw
+        @grammar = grammar
+        @falloff = 1
+        @random = Random.new
+        
+        @defaultUses = {}
+        
+        if(raw.is_a? Array) then
+            @defaultRules = raw
+        else
+            if(raw.is_a? String) then
+                @defaultRules = [raw];
+            else
+                # TODO: support for conditional and hierarchical rule sets
+            end
+        end
+    end
+    
+    def selectRule
+        # puts "Get rule #{@raw}"
+        
+        #TODO_ : RuleSet.getRule @ conditionalRule
+        #TODO_ : RuleSet.getRule @ ranking
+        
+        if(!@defaultRules.nil?) then
+            index = 0
+            # Select from this basic array of rules
+            # Get the distribution from the grammar if there is no other
+            distribution = @distribution || @grammar.distribution
+            case(distribution)
+                when "shuffle" then
+                    #create a shuffled deck
+                    if(@shuffledDeck.nil? || @shuffledDeck.empty?)
+                        #TODO_ - use fyshuffle and falloff
+                        @shuffledDeck = (0...@defaultRules.size).to_a.shuffle
+                    end
+                    index = @shuffledDeck.pop
+                when "weighted" then
+                    @errors << "Weighted distribution not yet implemented"
+                when "falloff" then
+                    @errors << "Falloff distribution not yet implemented"
+                else
+                    index = ((@random.rand ** @falloff) * @defaultRules.size).floor
+            end
+        
+            @defaultUses[index] = (@defaultUses[index] || 0) + 1
+            return @defaultRules[index]
+        end
+
+        @errors << "No default rules defined for #{self}"
+        return nil
+    end
+    
+    def clearState
+        @defaultUses = {}
+        #TODO_ should clear shuffled deck too?
+    end
+end
+
+class TracerySymbol
+    attr_accessor :isDynamic
+    
+    def initialize(grammar, key, rawRules)
+        # Symbols can be made with a single value, and array, or array of objects of (conditions/values)
+        @key = key
+        @grammar = grammar
+        @rawRules = rawRules
+        
+        @baseRules = RuleSet.new(@grammar, @rawRules)
+        clearState
+    end
+    
+    def clearState
+        # Clear the stack and clear all ruleset usages
+        @stack = [@baseRules]
+        @uses = []
+        @baseRules.clearState
+    end
+    
+    def pushRules(rawRules)
+        rules = RuleSet.new(@grammar, rawRules)
+        @stack.push rules
+    end
+    
+    def popRules
+        @stack.pop
+    end
+    
+    def selectRule(node, errors)
+        @uses.push({ node: node })
+        if(@stack.empty?) then
+            errors << "The rule stack for '#{@key}' is empty, too many pops?"
+            return "((#{@key}))"
+        end
+        return @stack.last.selectRule
+    end
+
+    def getActiveRules
+        return nil if @stack.empty?
+        return @stack.last.selectRule 
+    end
+
+    def rulesToJSON
+        return @rawRules.to_json
+    end
+end
+
+class Grammar
+    attr_accessor :distribution, :modifiers
+
+    def initialize(raw) #, settings
+        @modifiers = {}
+        loadFromRawObj(raw)
+    end
+    
+    def clearState
+        @symbols.each{|k,v| v.clearState} # TODO_ check for nil keys
+    end
+    
+    def addModifiers(mods)
+        # copy over the base modifiers
+        mods.each{|k,v| @modifiers[k] = v}
+    end
+    
+    def loadFromRawObj(raw)
+        @raw = raw
+        @symbols = {}
+        @subgrammars = []
+        return if(@raw.nil?)
+        @raw.each{|k,v|
+            @symbols[k] = TracerySymbol.new(self, k, v)
+        }
+    end
+    
+    def createRoot(rule)
+        # Create a node and subnodes
+        root = TraceryNode.new(self, 0, {
+                    type: -1,
+                    raw: rule
+                })
+        return root
+    end
+    
+    def expand(rule, allowEscapeChars = false)
+        root = createRoot(rule)
+        root.expand
+        root.clearEscapeCharacters if(!allowEscapeChars)
+        return root
+    end
+    
+    def flatten(rule, allowEscapeChars = false)
+        return expand(rule, allowEscapeChars).finishedText
+    end
+    
+    def pushRules(key, rawRules, sourceAction)
+        # Create or push rules
+        if(@symbols[key].nil?) then
+            @symbols[key] = TracerySymbol.new(self, key, rawRules)
+            @symbols[key].isDynamic = true if(sourceAction)
+        else
+            @symbols[key].pushRules(rawRules)
+        end
+    end
+    
+    def popRules(key)
+        errors << "No symbol for key #{key}" if(@symbols[key].nil?)
+        @symbols[key].popRules
+    end
+    
+    def selectRule(key, node, errors)
+        if(@symbols.has_key? key) then
+            return @symbols[key].selectRule(node, errors)
+        end
+        
+        # Failover to alternative subgrammars
+        @subgrammars.each do |subgrammar|
+            if(subgrammar.symbols.has_key? key) then
+                return subgrammar.symbols[key].selectRule
+            end
+        end
+        
+        # No symbol?
+        errors << "No symbol for '#{key}'"
+        return "((#{key}))"
+    end
+
+    def toJSON
+        symbols = @symbols.each.collect{|symkey, symval| "\"#{symkey}\": #{symval.rulesToJSON}"}
+        return "{\n#{symbols.join("\n")}\n}"
+    end
+end
+
+class TraceryTests
+    include Tracery
+    require 'pp'
+    
+    def test
+        tests = {
+            basic: ["", "a", "tracery"],
+            hashtag: ["#a#", "a#b#", "aaa#b##cccc#dd#eee##f#"],
+            hashtagWrong: ["##", "#", "a#a", "#aa#aa###"],
+            escape: ["\\#test\\#", "\\[#test#\\]"],
+        }
+        
+        tests.each do |key, testSet|
+            puts "For #{key}:"
+            testSet.each do |t|
+                result = parse(t)
+                puts "\tTesting \"#{t}\": #{result}"
+            end
+        end
+        
+        testGrammar = createGrammar({
+            "animal" => ["capybara", "unicorn", "university", "umbrella", "u-boat", "boa", "ocelot", "zebu", "finch", "fox", "hare", "fly"],
+            "color" => ["yellow", "maroon", "indigo", "ivory", "obsidian"],
+            "mood" => ["elated", "irritable", "morose", "enthusiastic"],
+            "story" => ["[mc:#animal#]Once there was #mc.a#, a very #mood# #mc#. In a pack of #color.ed# #mc.s#!"]
+        });
+        
+        require "./mods-eng-basic"
+        testGrammar.addModifiers(Modifiers.baseEngModifiers);
+        puts testGrammar.flatten("#story#")
+        
+        grammar = createGrammar({"origin" => "foo"});
+        grammar.addModifiers(Modifiers.baseEngModifiers);
+        puts grammar.flatten("#origin#")
+    end
+end
+
+if($PROGRAM_NAME == __FILE__) then
+    tests = TraceryTests.new
+    tests.test
+end

data/test/tracery_test.rb

@@ -0,0 +1,155 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib/')
+
+require 'test/unit'
+require 'tracery'
+require "mods-eng-basic"
+
+class TraceryTest < Test::Unit::TestCase
+    include Tracery
+    def setup
+        @grammar = createGrammar({
+            "deepHash" => ["\\#00FF00", "\\#FF00FF"],
+            "deeperHash" => ["#deepHash#"],
+            "animal" => ["bear", "cat", "dog", "fox", "giraffe", "hippopotamus"],
+            "mood" => ["quiet", "morose", "gleeful", "happy", "bemused", "clever", "jovial", "vexatious", "curious", "anxious", "obtuse", "serene", "demure"],
+
+            "nonrecursiveStory" => ["The #pet# went to the beach."],
+            # story : ["#recursiveStory#", "#recursiveStory#", "#nonrecursiveStory#"],
+            "recursiveStory" => ["The #pet# opened a book about[pet:#mood# #animal#] #pet.a#. #[#setPronouns#]story#[pet:POP] The #pet# closed the book."],
+
+            "svgColor" => ["rgb(120,180,120)", "rgb(240,140,40)", "rgb(150,45,55)", "rgb(150,145,125)", "rgb(220,215,195)", "rgb(120,250,190)"],
+            "svgStyle" => ['style="fill:#svgColor#;stroke-width:3;stroke:#svgColor#"'],
+
+            "name" => ["Cheri", "Fox", "Morgana", "Jedoo", "Brick", "Shadow", "Krox", "Urga", "Zelph"],
+            "story" => ["#hero.capitalize# was a great #occupation#, and this song tells of #heroTheir# adventure. #hero.capitalize# #didStuff#, then #heroThey# #didStuff#, then #heroThey# went home to read a book."],
+            "monster" => ["dragon", "ogre", "witch", "wizard", "goblin", "golem", "giant", "sphinx", "warlord"],
+            "setPronouns" => ["[heroThey:they][heroThem:them][heroTheir:their][heroTheirs:theirs]", "[heroThey:she][heroThem:her][heroTheir:her][heroTheirs:hers]", "[heroThey:he][heroThem:him][heroTheir:his][heroTheirs:his]"],
+            "setOccupation" => ["[occupation:baker][didStuff:baked bread,decorated cupcakes,folded dough,made croissants,iced a cake]", "[occupation:warrior][didStuff:fought #monster.a#,saved a village from #monster.a#,battled #monster.a#,defeated #monster.a#]"],
+            "origin" => ["#[#setPronouns#][#setOccupation#][hero:#name#]story#"]
+        })
+        @grammar.addModifiers(Modifiers.baseEngModifiers)
+    end
+
+    def test_main_expansion_tests
+        tests = {
+            plaintextShort: {
+               src: "a"
+            },
+            plaintextLong: {
+                src: "Emma Woodhouse, handsome, clever, and rich, with a comfortable home and happy disposition, seemed to unite some of the best blessings of existence; and had lived nearly twenty-one years in the world with very little to distress or vex her."
+            },
+
+        # Escape chars
+        escapeCharacter: {
+            src: "\\#escape hash\\# and escape slash\\\\"
+        },
+
+        escapeDeep: {
+            src: "#deepHash# [myColor:#deeperHash#] #myColor#"
+        },
+
+        escapeQuotes: {
+            src: "\"test\" and \'test\'"
+        },
+        escapeBrackets: {
+            src: "\\[\\]"
+        },
+        escapeHash: {
+            src: "\\#"
+        },
+        unescapeCharSlash: {
+            src: "\\\\"
+        },
+        escapeMelange1: {
+            src: "An action can have inner tags: \[key:\#rule\#\]"
+        },
+        escapeMelange2: {
+            src: "A tag can have inner actions: \"\\#\\[myName:\\#name\\#\\]story\\[myName:POP\\]\\#\""
+        },
+        emoji: {
+            src: "💻🐋🌙🏄🍻"
+        },
+
+        unicode: {
+            src: "&\\#x2665; &\\#x2614; &\\#9749; &\\#x2665;"
+        },
+
+        svg: {
+            src: '<svg width="100" height="70"><rect x="0" y="0" width="100" height="100" #svgStyle#/> <rect x="20" y="10" width="40" height="30" #svgStyle#/></svg>'
+        },
+
+        pushBasic: {
+            src: "[pet:#animal#]You have a #pet#. Your #pet# is #mood#."
+        },
+
+        pushPop: {
+            src: "[pet:#animal#]You have a #pet#. [pet:#animal#]Pet:#pet# [pet:POP]Pet:#pet#"
+        },
+
+        tagAction: {
+            src: "#[pet:#animal#]nonrecursiveStory# post:#pet#"
+        },
+
+        testComplexGrammar: {
+           src: "#origin#"
+        },
+
+        modifierWithParams: {
+            src: "[pet:#animal#]#nonrecursiveStory# -> #nonrecursiveStory.replace(beach,mall)#"
+        },
+
+        recursivePush: {
+           src: "[pet:#animal#]#recursiveStory#"
+        },
+
+        missingModifier: {
+            src: "#animal.foo#",
+            error: true
+        },
+
+        unmatchedHash: {
+            src: "#unmatched",
+            error: true
+        },
+        missingSymbol: {
+            src: "#unicorns#",
+            error: true
+        },
+        missingRightBracket: {
+            src: "[pet:unicorn",
+            error: true
+        },
+        missingLeftBracket: {
+            src: "pet:unicorn]",
+            error: true
+        },
+        justALotOfBrackets: {
+            src: "[][]][][][[[]]][[]]]]",
+            error: true
+        },
+        bracketTagMelange: {
+            src: "[][#]][][##][[[##]]][#[]]]]",
+            error: true
+        }
+        }
+
+        puts
+        tests.each { |k,v|
+            puts "#{k}: "
+            @grammar.clearState
+            source = v[:src]
+            is_error = v[:error].nil? ? false : v[:error]
+            root = @grammar.expand(source)
+            all_errors = root.allErrors
+            puts "\t#{root.finishedText}"
+            if(is_error) then
+                puts "\tErrors: #{all_errors}"
+                refute(all_errors.empty?, "Expected errors.")
+            else
+                assert(all_errors.empty?, "Expected no errors.")
+                refute(root.finishedText.empty?, "Expected non-empty output.")
+            end
+        }
+    end
+
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: tracery
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Kate Compton
+- Eli Brody
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-27 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Tracery is a library for text generation.
+  The text is expanded by traversing a grammar.
+  See the main github repo for examples and documentation.
+email: brodyeli@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mods-eng-basic.rb
+- lib/tracery.rb
+- test/tracery_test.rb
+homepage: https://github.com/galaxykate/tracery
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A text expansion library
+test_files:
+- test/tracery_test.rb