First stab at getting nodes to render.

joshthecoder · joshthecoder · commit 11ebb1fe59f0 · 2010-03-11T12:40:09.000-06:00
diff --git a/mustang/Context.ooc b/mustang/Context.ooc
@@ -0,0 +1,41 @@
+import structs/[HashMap, List]
+
+Value: abstract class {
+    typeName: abstract func -> String
+    toString: abstract func -> String
+}
+
+StringValue: class extends Value {
+    value: String
+
+    init: func(=value) {}
+
+    typeName: func -> String { "String" }
+
+    toString: func -> String { value }
+}
+
+ListValue: class <T> extends Value {
+    list: List<T>
+
+    init: func(=list) {}
+
+    typeName: func -> String { "List" }
+    toString: func -> String { "List size=%d" format(list size()) }
+
+    list: func -> List<T> { list }
+}
+
+Context: abstract class {
+    resolve: abstract func(name: String) -> Value
+}
+
+MockContext: class extends Context {
+    data: HashMap<Value>
+
+    init: func(=data) {}
+
+    resolve: func(name: String) -> Value {
+        data[name]
+    }
+}
diff --git a/mustang/Node.ooc b/mustang/Node.ooc
@@ -1,32 +1,41 @@
+import io/Writer
+import mustang/Context
+
 /**
     Base template node interface.
 */
 TNode: abstract class {
     next, firstChild: This
 
-    compile: abstract func
+    render: abstract func(context: Context, out: Writer)
+
     debug: abstract func -> String
 }
 
 /**
     Represents all the plain text in a template file.
 */
 TextNode: class extends TNode {
-    offset, length: Int
+    text: String
 
-    init: func(=offset, =length) {}
+    init: func(=text) {}
 
-    compile: func {}
+    render: func(context: Context, out: Writer) {
+        out write(text)
+    }
 
-    debug: func -> String { "Text: offset=%d length=%d" format(offset, length) }
+    debug: func -> String { "Text: '%s'" format(text) }
 }
 
 VariableNode: class extends TNode {
     variableName: String
 
     init: func(=variableName) {}
 
-    compile: func {}
+    render: func(context: Context, out: Writer) {
+        variable := context resolve(variableName)
+        out write(variable toString())
+    }
 
     debug: func -> String { "Variable: name=%s" format(variableName) }
 }
@@ -36,7 +45,8 @@ SectionNode: class extends TNode {
 
     init: func(=name) {}
 
-    compile: func {}
+    render: func(context: Context, out: Writer) {
+    }
 
     debug: func -> String { "Section: name=%s" format(name) }
 }
diff --git a/mustang/Renderer.ooc b/mustang/Renderer.ooc
@@ -0,0 +1,26 @@
+import io/Writer
+import text/Buffer
+import mustang/[Node, Walker, Context]
+
+
+Renderer: class extends NodeWalker {
+    rootNode: TNode
+    context: Context
+    output: Writer
+
+    init: func(=rootNode, =context) {}
+
+    onNode: func(node: TNode) {
+        node render(context, output)
+    }
+
+    render: func(output: Writer) {
+        this output = output
+        walk(rootNode, false)
+    }
+    render: func ~toString -> String {
+        buffer := Buffer new(1000)
+        render(BufferWriter new(buffer))
+        return buffer toString()
+    }
+}
diff --git a/mustang/TemplateParser.ooc b/mustang/TemplateParser.ooc
@@ -72,19 +72,16 @@ TemplateParser: class {
 
         start := template index()
         end := template skipUntil(startTag)
+
         if(end == -1) {
             // No more tags to parse, rest of context is plaintext.
-            length := template length() - start
-            if(length) {
-                appendNode(TextNode new(start, template length() - start))
-            }
+            text := template range(start)
+            appendNode(TextNode new(text))
             return false
         }
-        else {
-            length := end - start
-            if(length) {
-                appendNode(TextNode new(start, end - start))
-            }
+        else if(end != start) {
+            text := template range(start, end)
+            appendNode(TextNode new(text))
         }
 
         return true
diff --git a/mustang/TemplateReader.ooc b/mustang/TemplateReader.ooc
@@ -30,6 +30,13 @@ TemplateReader: class {
         return c
     }
 
+    range: func(start: Int, end: Int) -> String {
+        content substring(start, end)
+    }
+    range: func ~untilEnd(start: Int) -> String {
+        content substring(start)
+    }
+
     index: func -> Int { index }
 
     length: func -> Int { content length() }
diff --git a/mustang/Walker.ooc b/mustang/Walker.ooc
@@ -3,11 +3,14 @@ import mustang/Node
 NodeWalker: abstract class {
     root: TNode
     level: Int
+    visitChildren: Bool
 
     onNode: abstract func(node: TNode)
 
-    walk: func(root: TNode) {
+    walk: func(root: TNode, visitChildren: Bool) {
         level = -1
+        this visitChildren = visitChildren
+
         visit(root)
     }
 
@@ -17,7 +20,7 @@ NodeWalker: abstract class {
 
         while(c) {
             onNode(c)
-            if(c firstChild) visit(c firstChild)
+            if(visitChildren && c firstChild) visit(c firstChild)
             c = c next
         }
 
@@ -26,6 +29,14 @@ NodeWalker: abstract class {
 }
 
 NodePrinter: class extends NodeWalker {
+    rootNode: TNode
+
+    init: func(=rootNode) {}
+
+    print: func {
+        walk(rootNode, true)
+    }
+
     onNode: func(node: TNode) {
         "%s%s" format("--> " times(level), node debug()) println()
     }
