Implement some very basic error handling

It's a little hacky and not very clean but it's
working for now.

bin/oslo.js

       process.exit()
     }
 
+    if (output.error) {
+      this.error(output.error)
+    }
+
     if (opts.o) {
       const absoluteOutputPath = this.absolutePath(opts.o)
       if (opts.f || opts.e) {
       oslo -d templates -o html`,
     )
   }
+
+  error(err) {
+    console.log(err.message)
+    process.exit()
+  }
 }
 
 new OsloCLI(args)

src/error.js

+module.exports = class Error {
+  constructor(opts) {
+    this.file = opts.file
+    this.line = opts.line
+    this.message = opts.message
+  }
+}

src/index.js

   const tokens = lexer.scan(source)
   const parser = new Parser(tokens)
   const tree = parser.parse()
+
+  if (tree.error) {
+    return tree
+  }
+
   const compiler = new Compiler(tree, context)
   return compiler.compile()
 }

src/parser.js

+const Error = require('./Error')
 const Node = require('./node')
 const tokenTypes = require('./tokenTypes')
 
     let tree = []
     while (this.tokenStream.peek().type !== tokenTypes.EOF) {
       tree.push(this.expr())
+      if (this.tokenStream.error) {
+        return {
+          error: this.tokenStream.error,
+        }
+      }
     }
     return tree
   }
       this.tokenStream.peek().type !== tokenTypes.CPAREN &&
       this.tokenStream.peek().type !== tokenTypes.EOF
     ) {
+      if (this.tokenStream.error) return
+
       if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
         node = this.element()
       } else if (this.tokenStream.peek().type === tokenTypes.KEYWORD) {
         this.tokenStream.peek().type,
       )
     ) {
+      if (this.tokenStream.error) return
+
       if (this.tokenStream.peek().type === tokenTypes.ATTRIBUTE) {
         elementNode.args.push(this.attribute())
       } else if (this.tokenStream.peek().type === tokenTypes.QUOTE) {
       attributeNode.attributeValue = this.quotedString()
     } else if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
       attributeNode.attributeValue = this.identifier()
+    } else {
+      let token = this.tokenStream.peek()
+      this.tokenStream.error = new Error({
+        line: token.line,
+        message: `Encountered an unexpected ${token.type} while looking for a string or identifier.`
+      })
     }
 
     return attributeNode

src/tokenStream.js

+const Error = require('./error')
+
 module.exports = class TokenStream {
   constructor() {
     this.tokens = []
   }
 
   eat(tokenType) {
-    if (this.peek() && this.peek().type === tokenType) {
+    let token = this.peek()
+
+    if (token && token.type === tokenType) {
       this.advance()
-      return this.peek(-1)
+      return token
     }
-    return false
+
+    this.error = new Error({
+      line: token.line,
+      message: `Encountered an unexpected ${
+        token.type
+      } while looking for a ${tokenType}.`,
+    })
   }
 
   peek(step = 0) {

src/tokenTypes.js

   LITERAL: 'literal',
   ATTRIBUTE: 'attribute',
   SYMBOL: 'symbol',
-  EOF: 'eof',
+  EOF: 'EOF',
 }

test/parser.js

     }),
   ])
 })
+
+test('missing close paren returns an error', function(t) {
+  t.plan(2)
+  const lexer = new Lexer()
+  let tokenStream = lexer.scan(`
+    (div :class "foobar"
+  `)
+  let parser = new Parser(tokenStream)
+  let tree = parser.parse()
+  t.equal(tree.error.constructor.name, 'Error')
+  t.deepEqual(tree.error, {
+    file: undefined,
+    line: 3,
+    message: 'Encountered an unexpected EOF while looking for a ).',
+  })
+})
+
+test('unexpected attribute return an error', function(t) {
+  t.plan(2)
+  const lexer = new Lexer()
+  let tokenStream = lexer.scan(`
+    (div :class :id)
+  `)
+  let parser = new Parser(tokenStream)
+  let tree = parser.parse()
+  t.equal(tree.error.constructor.name, 'Error')
+  t.deepEqual(tree.error, {
+    file: undefined,
+    line: 2,
+    message: 'Encountered an unexpected attribute while looking for a string or identifier.',
+  })
+})