Implement test helper functions

package.json

   "description": "",
   "main": "index.js",
   "scripts": {
-    "test": "faucet test/*.js",
+    "test": "faucet test/*Test.js",
     "pretty": "prettier --single-quote --no-semi --trailing-comma all --arrow-parens avoid --write ./**/*.js"
   },
   "keywords": [],

test/compiler.js

-const test = require('tape')
-
-const Compiler = require('../src/compiler')
-const Lexer = require('../src/lexer')
-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('renders variables according to passed-in context', t => {
-  t.plan(1)
-  const lexer = new Lexer()
-  const tokenStream = lexer.scan(`
-    (div :class classOne
-      (p :class classTwo bodyText))
-  `)
-  const parser = new Parser(tokenStream)
-  const tree = parser.parse()
-  const compiler = new Compiler(tree, {
-    classOne: 'foobar',
-    classTwo: 'bazquux',
-    bodyText: 'Lorem ipsum dolor sit amet.',
-  })
-  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('self closing tags are respected', function(t) {
-  t.plan(1)
-  const lexer = new Lexer()
-  const tokenStream = lexer.scan(`
-    (meta :charset "UTF-8")
-    (img :src "test.png")
-  `)
-  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, ''),
-    '<meta charset="UTF-8"><img src="test.png">',
-  )
-})

test/compilerTest.js

+const test = require("tape");
+const helpers = require("./helpers");
+
+const tt = require("../src/tokenTypes");
+
+test("compiles a simple template", t => {
+  t.plan(1);
+  const result = helpers.compile(`
+    (div :class "foobar"
+      (p :class "bazquux" "Lorem ipsum dolor sit amet."))
+  `);
+  t.deepEqual(
+    result.replace(/\n/g, "").replace(/  +/g, ""),
+    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>'
+  );
+});
+
+test("renders variables according to passed-in context", t => {
+  t.plan(1);
+  const result = helpers.compile(
+    `
+      (div :class classOne
+        (p :class classTwo bodyText))
+    `,
+    {
+      classOne: "foobar",
+      classTwo: "bazquux",
+      bodyText: "Lorem ipsum dolor sit amet."
+    }
+  );
+  t.deepEqual(
+    result.replace(/\n/g, "").replace(/  +/g, ""),
+    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>'
+  );
+});
+
+test("self closing tags are respected", function(t) {
+  t.plan(1);
+  const result = helpers.compile(`
+    (meta :charset "UTF-8")
+    (img :src "test.png")
+  `);
+  t.deepEqual(
+    result.replace(/\n/g, "").replace(/  +/g, ""),
+    '<meta charset="UTF-8"><img src="test.png">'
+  );
+});

test/helpers.js

+const Compiler = require("../src/compiler");
+const Lexer = require("../src/lexer");
+const Parser = require("../src/parser");
+
+const scan = source => {
+  const lexer = new Lexer();
+  return lexer.scan(source);
+};
+
+const parse = source => {
+  const parser = new Parser(scan(source));
+  return parser.parse();
+};
+
+const compile = (source, context) => {
+  const compiler = new Compiler(parse(source), context);
+  return compiler.compile();
+};
+
+module.exports = {
+  scan: scan,
+  parse: parse,
+  compile: compile
+};

test/lexer.js → test/lexerTest.js

 const test = require('tape')
+const helpers = require('./helpers')
 
-const Lexer = require('../src/lexer')
 const tt = require('../src/tokenTypes')
 
 test('lexes simple template correctly', t => {
   t.plan(4)
-  const lexer = new Lexer()
-  let tokens = lexer.scan(
+  let tokens = helpers.scan(
     '(div :class "foobar" (p "Lorem ipsum dolor sit amet"))',
   ).tokens
   t.deepEqual(tokens.map(token => token.type), [
 
 test('keeps track of line numbers', t => {
   t.plan(2)
-  const lexer = new Lexer()
-  let tokens = lexer.scan(`(
+  let tokens = helpers.scan(`(
     (div :class "foobar"
       (p :class "bazquux"))
   `).tokens
 
 test('multiple identifiers in a row are kept separate', t => {
   t.plan(2)
-  const lexer = new Lexer()
-  let tokens = lexer.scan(`(test test test)`).tokens
+  let tokens = helpers.scan(`(test test test)`).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
     tt.IDENTIFIER,
     tt.CPAREN,
     tt.EOF,
   ])
-  tokens = lexer.scan(`(test "test" test test)`).tokens
+  tokens = helpers.scan(`(test "test" test test)`).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
     tt.IDENTIFIER,
 
 test('allow special characters inside quotes', t => {
   t.plan(2)
-  const lexer = new Lexer()
-  let tokens = lexer.scan(`
+  let tokens = helpers.scan(`
     (p "(test)")
   `).tokens
   t.deepEqual(tokens.map(token => token.type), [
 
 test('lex numbers', t => {
   t.plan(2)
-  const lexer = new Lexer()
-  let tokens = lexer.scan('1 2 3 4 5').tokens
+  let tokens = helpers.scan('1 2 3 4 5').tokens
   t.deepEqual(tokens.map(token => token.type), [
-    tt.NUMBER, tt.NUMBER, tt.NUMBER, tt.NUMBER, tt.NUMBER, tt.EOF,
+    tt.NUMBER,
+    tt.NUMBER,
+    tt.NUMBER,
+    tt.NUMBER,
+    tt.NUMBER,
+    tt.EOF,
   ])
   t.deepEqual(tokens.map(token => token.value), [
-    1, 2, 3, 4, 5, undefined // undefined is for the EOF
+    1,
+    2,
+    3,
+    4,
+    5,
+    undefined, // undefined is for the EOF
   ])
 })
 
 test('lex booleans', t => {
   t.plan(2)
-  const lexer = new Lexer()
-  let tokens = lexer.scan('#t #f').tokens
-  t.deepEqual(tokens.map(token => token.type), [
-    tt.BOOLEAN, tt.BOOLEAN, tt.EOF
-  ])
+  let tokens = helpers.scan('#t #f').tokens
+  t.deepEqual(tokens.map(token => token.type), [tt.BOOLEAN, tt.BOOLEAN, tt.EOF])
   t.deepEqual(tokens.map(token => token.value), [
-    true, false, undefined // undefined is for the EOF
+    true,
+    false,
+    undefined, // undefined is for the EOF
   ])
 })
-

test/parser.js → test/parserTest.js

 const test = require('tape')
+const helpers = require('./helpers')
 
-const Lexer = require('../src/lexer')
 const AST = require('../src/ast/index')
-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(`
+  const tree = helpers.parse(`
     (div :class "foobar"
       (p :class (cond #t "primary" "secondary")))
   `)
-  let parser = new Parser(tokenStream)
-  let tree = parser.parse()
 
   t.deepEqual(tree, [
     new AST.Application({
       args: [
         new AST.Attribute({
           name: 'class',
-          value: new AST.String({ value: 'foobar' })
+          value: new AST.String({ value: 'foobar' }),
         }),
         new AST.Application({
           functionName: new AST.Identifier({ name: 'p' }),
                   new AST.Boolean({ value: true }),
                   new AST.String({ value: 'primary' }),
                   new AST.String({ value: 'secondary' }),
-                ]
-              })
-            })
-          ]
-        })
-      ]
-    })
+                ],
+              }),
+            }),
+          ],
+        }),
+      ],
+    }),
   ])
 })
 
 test('allow empty strings', t => {
   t.plan(1)
-  const lexer = new Lexer()
-  const tokenStream = lexer.scan('(p "")')
-  const parser = new Parser(tokenStream)
-  const tree = parser.parse()
+  const tree = helpers.parse('(p "")')
 
   t.deepEqual(tree, [
     new AST.Application({
       functionName: new AST.Identifier({ name: 'p' }),
-      args: [
-        new AST.String({ value: '' })
-      ]
-    })
+      args: [new AST.String({ value: '' })],
+    }),
   ])
 })