First try at the compiler

No variables or conditionals or anything yet, just
the basic ability to turn s-expressions into HTML.

src/compiler.js

@@ -0,0 +1,25 @@
+module.exports = class Compiler {
+  constructor(tree) {
+    this.tree = tree
+    this.result = ''
+  }
+
+  compile() {
+    this.tree.forEach(node => {
+      if (node.type === 'functionCall') {
+        const attributes = node.args.map(arg => `${arg.attributeName}="${arg.attributeValue}"`)
+        const compiler = new Compiler(node.subtree)
+        const content = compiler.compile()
+        this.result += `
+          <${node.functionName}${attributes.length ? ' ' : ''}${attributes.join(' ')}>
+            ${content}
+          </${node.functionName}>
+        `
+      } else if (node.type === 'text') {
+        this.result += node.content
+      }
+    })
+
+    return this.result
+  }
+}

src/parser.js

@@ -17,22 +17,28 @@ module.exports = class Parser {
   expr() {
     this.tokenStream.eat(tokenTypes.OPAREN)
 
-    let functionCallNode = new Node()
-    functionCallNode.functionName = this.tokenStream.eat(tokenTypes.LITERAL).value
-    functionCallNode.args = []
-    functionCallNode.subtree = []
+    let elementNode = new Node()
+    elementNode.type = 'functionCall'
+    elementNode.functionName = this.tokenStream.eat(tokenTypes.LITERAL).value
+    elementNode.args = []
+    elementNode.subtree = []
 
     while (this.tokenStream.peek().type != tokenTypes.CPAREN && this.tokenStream.peek().type !== tokenTypes.EOF) {
       if (this.tokenStream.peek().type === tokenTypes.ATTRIBUTE) {
-        functionCallNode.args.push(this.attribute())
+        elementNode.args.push(this.attribute())
       } else if (this.tokenStream.peek().type === tokenTypes.OPAREN) {
-        functionCallNode.subtree.push(this.expr())
+        elementNode.subtree.push(this.expr())
+      } else if (this.tokenStream.peek().type === tokenTypes.QUOTE) {
+        elementNode.subtree.push(new Node({
+          type: 'text',
+          content: this.string()
+        }))
       }
     }
 
     this.tokenStream.eat(tokenTypes.CPAREN)
 
-    return functionCallNode
+    return elementNode
   }
 
   attribute() {

test/compiler.js

@@ -0,0 +1,24 @@
+const test = require("tape")
+
+const Compiler = require("../src/compiler")
+const Lexer = require("../src/lexer")
+const Node = require("../src/node")
+const Parser = require("../src/parser")
+const tt = require("../src/tokenTypes")
+
+test("compiles a simple template", t => {
+  t.plan(1)
+  const lexer = new Lexer()
+  const tokenStream = lexer.scan(`
+    (div :class "foobar"
+      (p :class "bazquux" "Lorem ipsum dolor sit amet."))
+  `)
+  const parser = new Parser(tokenStream)
+  const tree = parser.parse()
+  const compiler = new Compiler(tree)
+  const result = compiler.compile()
+  t.deepEqual(
+    result.replace(/\n/g, '').replace(/  +/g, ''),
+    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>'
+  )
+})

test/parser.js

@@ -19,6 +19,7 @@ test('parses token stream into a tree', t => {
     tree,
     [
       new Node({
+        type: 'functionCall',
         functionName: 'div',
         args: [
           new Node({
@@ -28,6 +29,7 @@ test('parses token stream into a tree', t => {
         ],
         subtree: [
           new Node({
+            type: 'functionCall',
             functionName: 'p',
             args: [
               new Node({