Merge TemplateReader into TemplateParser.

joshthecoder · joshthecoder · commit e848f00973c4 · 2010-03-19T18:08:21.000-05:00
diff --git a/mustang/TagParser.ooc b/mustang/TagParser.ooc
@@ -87,7 +87,7 @@ PartialParser: class extends TagParser {
     parse: func(tag: String) -> TNode {
         //TODO: better template path lookups
         templateName := tag substring(1) trim()
-        template := Template loadFromFile("%s.mustache" format(templateName))
+        template := Template loadFromPath("%s.mustache" format(templateName))
 
         PartialNode new(template)
     }
diff --git a/mustang/Template.ooc b/mustang/Template.ooc
@@ -1,20 +1,14 @@
 import io/[Writer, File]
-import mustang/[Context, TemplateParser, TemplateReader, Renderer]
+import mustang/[Context, TemplateParser, Renderer]
 
 Template: class {
     renderer: Renderer
 
-    loadFromFile: static func(path: String) -> This {
-        This new(TemplateReader getReaderFromFile(File new(path)))
+    loadFromPath: static func(path: String) -> This {
+        new(TemplateParser getParserFromFile(File new(path)))
     }
 
-    loadFromString: static func(text: String) -> This {
-        This new(TemplateReader new(text))
-    }
-
-    init: func(reader: TemplateReader) { this(reader, "{{", "}}") }
-    init: func ~customTags(reader: TemplateReader, startTag: String, endTag: String) {
-        parser := TemplateParser new(reader, startTag, endTag)
+    init: func(parser: TemplateParser) {
         rootNode := parser parse()
         renderer = Renderer new(rootNode)
     }
diff --git a/mustang/TemplateParser.ooc b/mustang/TemplateParser.ooc
@@ -1,5 +1,8 @@
+import mustang/[Node, TagParser]
+
+import io/[File, FileReader]
 import structs/[Stack, List, LinkedList]
-import mustang/[TemplateReader, Node, TagParser]
+
 
 /**
     Parses the template text and returns a list of token Nodes.
@@ -15,15 +18,26 @@ import mustang/[TemplateReader, Node, TagParser]
     to the NodeList returned at the end of parsing.
 */
 TemplateParser: class {
-    template: TemplateReader
+    templateText: String
+    index: Int
+
     startTag, endTag: String
     parsers: LinkedList<TagParser>
+
     firstNode, currentNode: TNode
     nodeStack: Stack<TNode>
-    currentBlockName: String
     running: Bool
 
-    init: func(=template, =startTag, =endTag) {
+    getParserFromFile: static func(file: File) -> This {
+        size := file size()
+        buffer: String = gc_malloc(size + 1)
+        FileReader new(file) read(buffer, 0, size)
+        buffer[size] = '\0';
+        return new(buffer, "{{", "}}")  //TODO: un-hardcode
+    }
+
+    init: func(=templateText, =startTag, =endTag) {
+        index = 0
         parsers = LinkedList<TagParser> new()
         nodeStack = Stack<TNode> new()
 
@@ -65,34 +79,38 @@ TemplateParser: class {
     }
 
     parseText: func -> Bool {
-        if(!template hasNext()) {
+        if(index >= templateText length()) {
             // End of template, stop parsing
             return false
         }
 
-        start := template index()
-        end := template skipUntil(startTag)
+        // Find the start of the next tag
+        indexOfNextTag := templateText indexOf(startTag, index)
 
-        if(end == -1) {
+        if(indexOfNextTag == -1) {
             // No more tags to parse, rest of context is plaintext.
-            text := template range(start)
+            text := templateText substring(index)
             appendNode(TextNode new(text))
             return false
         }
-        else if(end != start) {
-            text := template range(start, end)
+        else if(indexOfNextTag != index) {
+            text := templateText substring(index, indexOfNextTag)
             appendNode(TextNode new(text))
         }
 
+        index = indexOfNextTag
+
         return true
     }
 
     parseTag: func -> Bool {
         // Read the tag from the template
-        template skip(startTag length())            // opening mustaches {{
-        tag := template readUntil(endTag)           // tag body
-        tag = tag trim()
-        template skip(endTag length())              // closing mustaches }}
+        //TODO: probably best we do this in a regex.
+        // as of now triple mustaches don't parse right.
+        index += startTag length()  // skip open tag
+        indexOfEndTag := templateText indexOf(endTag, index)  // get index of end tag
+        tag := templateText substring(index, indexOfEndTag) trim()  // substring out the tag content
+        index = indexOfEndTag + endTag length()  // advance past end tag
 
         // End of tag block
         if(tag first() == '/') {
diff --git a/mustang/TemplateReader.ooc b/mustang/TemplateReader.ooc
diff --git a/mustang/mustang.ooc b/mustang/mustang.ooc
@@ -18,7 +18,7 @@ main: func(args: ArrayList<String>) -> Int {
     }
 
     context := YAMLContext loadFromFile(yamlFile)
-    template := Template loadFromFile(templateFile)
+    template := Template loadFromPath(templateFile)
     template render(context) println()
 
     return 0

Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ PartialParser: class extends TagParser {`
`87`	`87`	`parse: func(tag: String) -> TNode {`
`88`	`88`	`//TODO: better template path lookups`
`89`	`89`	`templateName := tag substring(1) trim()`
`90`		`- template := Template loadFromFile("%s.mustache" format(templateName))`
	`90`	`+ template := Template loadFromPath("%s.mustache" format(templateName))`
`91`	`91`
`92`	`92`	`PartialNode new(template)`
`93`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ main: func(args: ArrayList<String>) -> Int {`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`context := YAMLContext loadFromFile(yamlFile)`
`21`		`- template := Template loadFromFile(templateFile)`
	`21`	`+ template := Template loadFromPath(templateFile)`
`22`	`22`	`template render(context) println()`
`23`	`23`
`24`	`24`	`return 0`