Run prettier

bin/oslo.js

       output = this.file(path.join(process.cwd(), opts.f))
     } else if (opts.d) {
       if (!opts.o) {
-        console.log('Output directory required. Invoke oslo with `-o path/to/output/directory`')
+        console.log(
+          'Output directory required. Invoke oslo with `-o path/to/output/directory`',
+        )
         process.exit()
       }
-      output = this.directory(this.absolutePath(opts.d), this.absolutePath(opts.o))
+      output = this.directory(
+        this.absolutePath(opts.d),
+        this.absolutePath(opts.o),
+      )
     } else if (opts.e) {
       output = this.inline(opts.e)
     } else {
     if (opts.o) {
       const absoluteOutputPath = this.absolutePath(opts.o)
       if (opts.f || opts.e) {
-        fs.writeFile(absoluteOutputPath, output, function (err) {
+        fs.writeFile(absoluteOutputPath, output, function(err) {
           if (err) throw err
         })
       } else if (opts.d) {
         const absoluteInputPath = this.absolutePath(opts.d)
-        Object.keys(output).forEach(function (file) {
-          const absoluteOutputFilePath = file.replace(absoluteInputPath, absoluteOutputPath).replace(/\.oslo$/, '.html')
+        Object.keys(output).forEach(function(file) {
+          const absoluteOutputFilePath = file
+            .replace(absoluteInputPath, absoluteOutputPath)
+            .replace(/\.oslo$/, '.html')
           const parentDirectory = path.dirname(absoluteOutputFilePath)
           if (!fs.existsSync(parentDirectory)) {
             fs.mkdirSync(parentDirectory)
           }
-          fs.writeFile(absoluteOutputFilePath, output[file], function (err) {
+          fs.writeFile(absoluteOutputFilePath, output[file], function(err) {
             if (err) throw err
-            console.log(`Writing to ${absoluteOutputFilePath.replace(process.cwd(), '')}`)
+            console.log(
+              `Writing to ${absoluteOutputFilePath.replace(process.cwd(), '')}`,
+            )
           })
         })
       }
 
   printUsage() {
     console.log(
-`USAGE
+      `USAGE
 
   -d The path to a directory. The directory will be recursively scanned. An
      output directory is required with this option.
      will be created if it does not already exist.
 
       oslo -f index.oslo -o index.html
-      oslo -d templates -o html`
+      oslo -d templates -o html`,
     )
   }
 }
 
-(new OsloCLI(args))
+new OsloCLI(args)

src/compiler.js

   compile() {
     this.tree.forEach(node => {
       if (node.type === 'functionCall') {
-        const attributes = node.args.map(arg => `${arg.attributeName}="${this.compileAttribute(arg.attributeValue)}"`)
+        const attributes = node.args.map(
+          arg =>
+            `${arg.attributeName}="${this.compileAttribute(
+              arg.attributeValue,
+            )}"`,
+        )
         const compiler = new Compiler(node.subtree, this.context)
         const content = compiler.compile()
-        this.result += `<${node.functionName}${attributes.length ? ' ' : ''}${attributes.join(' ')}>${content}</${node.functionName}>`
+        this.result += `<${node.functionName}${
+          attributes.length ? ' ' : ''
+        }${attributes.join(' ')}>${content}</${node.functionName}>`
       } else if (node.type === 'string') {
         this.result += node.content
       } else if (node.type === 'identifier') {

src/parser.js

     elementNode.args = []
     elementNode.subtree = []
 
-    while (this.tokenStream.peek().type != tokenTypes.CPAREN && this.tokenStream.peek().type !== tokenTypes.EOF) {
+    while (
+      this.tokenStream.peek().type != tokenTypes.CPAREN &&
+      this.tokenStream.peek().type !== tokenTypes.EOF
+    ) {
       if (this.tokenStream.peek().type === tokenTypes.ATTRIBUTE) {
         elementNode.args.push(this.attribute())
       } else if (this.tokenStream.peek().type === tokenTypes.OPAREN) {
 
   attribute() {
     let attributeNode = new Node()
-    attributeNode.attributeName = this.tokenStream.eat(tokenTypes.ATTRIBUTE).value
+    attributeNode.attributeName = this.tokenStream.eat(
+      tokenTypes.ATTRIBUTE,
+    ).value
     if (this.tokenStream.peek().type === tokenTypes.QUOTE) {
       attributeNode.attributeValue = this.quotedString()
     } else if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
     const identifier = this.tokenStream.eat(tokenTypes.LITERAL)
     return new Node({
       type: 'identifier',
-      name: identifier.value
+      name: identifier.value,
     })
   }
 
   quotedString() {
     return new Node({
       type: 'string',
-      content: this.string()
+      content: this.string(),
     })
   }
 

test/compiler.js

-const test = require("tape")
+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")
+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 => {
+test('compiles a simple template', t => {
   t.plan(1)
   const lexer = new Lexer()
   const tokenStream = lexer.scan(`
   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>'
+    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>',
   )
 })
 
-test("renders variables according to passed-in context", t => {
+test('renders variables according to passed-in context', t => {
   t.plan(1)
   const lexer = new Lexer()
   const tokenStream = lexer.scan(`
   const compiler = new Compiler(tree, {
     classOne: 'foobar',
     classTwo: 'bazquux',
-    bodyText: 'Lorem ipsum dolor sit amet.'
+    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>'
+    '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>',
   )
 })

test/lexer.js

   t.plan(2)
   const lexer = new Lexer()
   let tokens = lexer.scan(`(test test test)`).tokens
-  t.deepEqual(
-    tokens.map(token => token.type),
-    [
-      tt.OPAREN,
-      tt.LITERAL,
-      tt.LITERAL,
-      tt.LITERAL,
-      tt.CPAREN,
-      tt.EOF,
-    ]
-  )
+  t.deepEqual(tokens.map(token => token.type), [
+    tt.OPAREN,
+    tt.LITERAL,
+    tt.LITERAL,
+    tt.LITERAL,
+    tt.CPAREN,
+    tt.EOF,
+  ])
   tokens = lexer.scan(`(test "test" test test)`).tokens
-  t.deepEqual(
-    tokens.map(token => token.type),
-    [
-      tt.OPAREN,
-      tt.LITERAL,
-      tt.QUOTE,
-      tt.LITERAL,
-      tt.QUOTE,
-      tt.LITERAL,
-      tt.LITERAL,
-      tt.CPAREN,
-      tt.EOF,
-    ]
-  )
+  t.deepEqual(tokens.map(token => token.type), [
+    tt.OPAREN,
+    tt.LITERAL,
+    tt.QUOTE,
+    tt.LITERAL,
+    tt.QUOTE,
+    tt.LITERAL,
+    tt.LITERAL,
+    tt.CPAREN,
+    tt.EOF,
+  ])
 })
 
 test('allow special characters inside quotes', t => {
   let tokens = lexer.scan(`
     (p "(test)")
   `).tokens
-  t.deepEqual(
-    tokens.map(token => token.type),
-    [
-      tt.OPAREN,
-      tt.LITERAL,
-      tt.QUOTE,
-      tt.LITERAL,
-      tt.QUOTE,
-      tt.CPAREN,
-      tt.EOF,
-    ]
-  )
+  t.deepEqual(tokens.map(token => token.type), [
+    tt.OPAREN,
+    tt.LITERAL,
+    tt.QUOTE,
+    tt.LITERAL,
+    tt.QUOTE,
+    tt.CPAREN,
+    tt.EOF,
+  ])
   t.equal(tokens[3].value, '(test)')
 })

test/parser.js

   let parser = new Parser(tokenStream)
   let tree = parser.parse()
 
-  t.deepEqual(
-    tree,
-    [
-      new Node({
-        type: 'functionCall',
-        functionName: 'div',
-        args: [
-          new Node({
-            attributeName: 'class',
-            attributeValue: new Node({type: 'string', content: 'foobar'}),
-          })
-        ],
-        subtree: [
-          new Node({
-            type: 'functionCall',
-            functionName: 'p',
-            args: [
-              new Node({
-                attributeName: 'class',
-                attributeValue: new Node({type: 'string', content: 'bazquux'}),
-              })
-            ],
-            subtree: [],
-          })
-        ]
-      })
-    ]
-  )
+  t.deepEqual(tree, [
+    new Node({
+      type: 'functionCall',
+      functionName: 'div',
+      args: [
+        new Node({
+          attributeName: 'class',
+          attributeValue: new Node({ type: 'string', content: 'foobar' }),
+        }),
+      ],
+      subtree: [
+        new Node({
+          type: 'functionCall',
+          functionName: 'p',
+          args: [
+            new Node({
+              attributeName: 'class',
+              attributeValue: new Node({ type: 'string', content: 'bazquux' }),
+            }),
+          ],
+          subtree: [],
+        }),
+      ],
+    }),
+  ])
 })