Fix up some stuff and add a test for parser

src/node.js

@@ -1,2 +1,9 @@
 module.exports = class Node {
+  constructor(opts = false) {
+    if (opts) {
+      Object.keys(opts).forEach(opt => {
+        this[opt] = opts[opt]
+      })
+    }
+  }
 }

src/parser.js

@@ -2,56 +2,50 @@ const Node = require('./node')
 const tokenTypes = require('./tokenTypes')
 
 module.exports = class Parser {
-  constructor(tokens) {
-    this.tokens = tokens
+  constructor(tokenStream) {
+    this.tokenStream = tokenStream
   }
 
   parse() {
     let tree = []
-    while (this.tokens.peek().type !== tokenTypes.EOF) {
+    while (this.tokenStream.peek().type !== tokenTypes.EOF) {
       tree.push(this.expr())
     }
     return tree
   }
 
   expr() {
-    this.tokens.eat(tokenTypes.OPAREN)
-
-    let tokenTypesToEndTheLoop = [
-      tokenTypes.OPAREN,
-      tokenTypes.CPAREN,
-      tokenTypes.EOF,
-    ]
+    this.tokenStream.eat(tokenTypes.OPAREN)
 
     let functionCallNode = new Node()
-    functionCallNode.functionName = this.tokens.eat(tokenTypes.LITERAL).value
+    functionCallNode.functionName = this.tokenStream.eat(tokenTypes.LITERAL).value
     functionCallNode.args = []
     functionCallNode.subtree = []
 
-    while (this.tokens.peek().type != tokenTypes.CPAREN) {
-      if (this.tokens.peek().type === tokenTypes.ATTRIBUTE) {
+    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())
-      } else if (this.tokens.peek().type === tokenTypes.OPAREN) {
-        functionCallNode.subtree = this.expr()
+      } else if (this.tokenStream.peek().type === tokenTypes.OPAREN) {
+        functionCallNode.subtree.push(this.expr())
       }
     }
 
-    this.tokens.eat(tokenTypes.CPAREN)
+    this.tokenStream.eat(tokenTypes.CPAREN)
 
     return functionCallNode
   }
 
   attribute() {
     let attributeNode = new Node()
-    attributeNode.attributeName = this.tokens.eat(tokenTypes.ATTRIBUTE).value
+    attributeNode.attributeName = this.tokenStream.eat(tokenTypes.ATTRIBUTE).value
     attributeNode.attributeValue = this.string()
     return attributeNode
   }
 
   string() {
-    this.tokens.eat(tokenTypes.QUOTE)
-    let stringValue = this.tokens.eat(tokenTypes.LITERAL).value
-    this.tokens.eat(tokenTypes.QUOTE)
+    this.tokenStream.eat(tokenTypes.QUOTE)
+    let stringValue = this.tokenStream.eat(tokenTypes.LITERAL).value
+    this.tokenStream.eat(tokenTypes.QUOTE)
     return stringValue
   }
 }

src/tokenStream.js

@@ -1,6 +1,5 @@
-module.exports = class TokenStream extends Array {
+module.exports = class TokenStream {
   constructor() {
-    super()
     this.tokens = []
     this.position = 0
   }

test/parser.js

@@ -0,0 +1,44 @@
+const test = require('tape')
+
+const Lexer = require('../src/lexer')
+const Node = require('../src/node')
+const Parser = require('../src/parser')
+const tt = require('../src/tokenTypes')
+
+test('parses token stream into a tree', t => {
+  t.plan(1)
+  const lexer = new Lexer()
+  let tokenStream = lexer.scan(`
+    (div :class "foobar"
+      (p :class "bazquux"))
+  `)
+  let parser = new Parser(tokenStream)
+  let tree = parser.parse()
+
+  t.deepEqual(
+    tree,
+    [
+      new Node({
+        functionName: 'div',
+        args: [
+          new Node({
+            attributeName: 'class',
+            attributeValue: 'foobar',
+          })
+        ],
+        subtree: [
+          new Node({
+            functionName: 'p',
+            args: [
+              new Node({
+                attributeName: 'class',
+                attributeValue: 'bazquux',
+              })
+            ],
+            subtree: [],
+          })
+        ]
+      })
+    ]
+  )
+})