Prettier

src/compiler.js

-const selfClosingTags = require('./util/selfClosingTags')
+const selfClosingTags = require("./util/selfClosingTags");
 
 module.exports = class Compiler {
   constructor(tree, context) {
-    this.tree = tree
-    this.context = context
-    this.pos = 0
-    this.result = ''
+    this.tree = tree;
+    this.context = context;
+    this.pos = 0;
+    this.result = "";
   }
 
   compile() {
     this.tree.forEach(node => {
       switch (node.constructor.name) {
-        case 'Application':
-          this.result += this.application(node)
+        case "Application":
+          this.result += this.application(node);
           break;
-        case 'Identifier':
-          this.result += this.lookup(node)
+        case "Identifier":
+          this.result += this.lookup(node);
           break;
-        case 'String':
+        case "String":
           this.result += node.value;
           break;
       }
-    })
+    });
 
-    return this.result
+    return this.result;
   }
 
   application(node) {
-    let result = `<${node.functionName.name}`
+    let result = `<${node.functionName.name}`;
 
-    node.args.filter(arg => arg.constructor.name === 'Attribute').forEach(arg => {
-      result += ` ${arg.name}`
+    node.args
+      .filter(arg => arg.constructor.name === "Attribute")
+      .forEach(arg => {
+        result += ` ${arg.name}`;
 
-      let compiler = new Compiler([arg.value], this.context)
-      let attrValue = compiler.compile()
+        let compiler = new Compiler([arg.value], this.context);
+        let attrValue = compiler.compile();
 
-      if (attrValue) {
-       result += `="${attrValue}"`
-      }
-    })
+        if (attrValue) {
+          result += `="${attrValue}"`;
+        }
+      });
 
-    result += '>'
+    result += ">";
 
-    node.args.filter(arg => arg.constructor.name !== 'Attribute').forEach(arg => {
-      let compiler = new Compiler([arg], this.context)
-      result += compiler.compile()
-    })
+    node.args
+      .filter(arg => arg.constructor.name !== "Attribute")
+      .forEach(arg => {
+        let compiler = new Compiler([arg], this.context);
+        result += compiler.compile();
+      });
 
     if (!selfClosingTags.includes(node.functionName.name)) {
-      result += `</${node.functionName.name}>`
+      result += `</${node.functionName.name}>`;
     }
 
-    return result
+    return result;
   }
 
   lookup(identifier) {
-    let result = this.context[identifier.name]
+    let result = this.context[identifier.name];
 
     if (!result) {
-      throw `Undefined variable '${identifier.name}'`
+      throw `Undefined variable '${identifier.name}'`;
     }
 
-    return result
+    return result;
   }
-}
+};

src/lexer.js

-const TokenStream = require('./tokenStream')
-const tokenTypes = require('./tokenTypes')
+const TokenStream = require("./tokenStream");
+const tokenTypes = require("./tokenTypes");
 
 module.exports = class Lexer {
   scan(source) {
-    let pos = 0
-    let line = 1
-    let tokenStream = new TokenStream()
-    let allowSpecialCharactersInLiterals = false
+    let pos = 0;
+    let line = 1;
+    let tokenStream = new TokenStream();
+    let allowSpecialCharactersInLiterals = false;
 
     while (pos < source.length) {
       if (source[pos].match(/\(/) && !allowSpecialCharactersInLiterals) {
         tokenStream.tokens.push({
           type: tokenTypes.OPAREN,
-          line: line,
-        })
-        pos++
+          line: line
+        });
+        pos++;
       } else if (source[pos].match(/\)/)) {
         tokenStream.tokens.push({
           type: tokenTypes.CPAREN,
-          line: line,
-        })
-        pos++
+          line: line
+        });
+        pos++;
       } else if (source[pos].match(/["]/)) {
-        allowSpecialCharactersInLiterals = !allowSpecialCharactersInLiterals
+        allowSpecialCharactersInLiterals = !allowSpecialCharactersInLiterals;
         tokenStream.tokens.push({
           type: tokenTypes.QUOTE,
-          line: line,
-        })
-        pos++
+          line: line
+        });
+        pos++;
       } else if (source[pos].match(/:/)) {
-        let value = /:([^()'"\s]+)/.exec(source.slice(pos))[1].trim()
+        let value = /:([^()'"\s]+)/.exec(source.slice(pos))[1].trim();
         tokenStream.tokens.push({
           type: tokenTypes.ATTRIBUTE,
           line: line,
-          value: value,
-        })
-        pos += value.length + 1 // the +1 is to account for the colon
+          value: value
+        });
+        pos += value.length + 1; // the +1 is to account for the colon
       } else if (source[pos].match(/\'/)) {
-        let value = /'([^()"\s]+)/.exec(source.slice(pos))[1].trim()
+        let value = /'([^()"\s]+)/.exec(source.slice(pos))[1].trim();
         tokenStream.tokens.push({
           type: tokenTypes.SYMBOL,
           line: line,
-          value: value,
-        })
-        pos += value.length + 1 // the +1 is to account for the apostrophe
+          value: value
+        });
+        pos += value.length + 1; // the +1 is to account for the apostrophe
       } else if (source[pos].match(/\d/)) {
-        let number = ''
+        let number = "";
         while (source[pos] && source[pos].match(/\d/)) {
-          number += source[pos]
-          pos++
+          number += source[pos];
+          pos++;
         }
         tokenStream.tokens.push({
           type: tokenTypes.NUMBER,
           line: line,
-          value: parseFloat(number),
-        })
+          value: parseFloat(number)
+        });
       } else if (source.slice(pos).match(/^#(t|f)/)) {
-        pos++
+        pos++;
         tokenStream.tokens.push({
           type: tokenTypes.BOOLEAN,
           line: line,
-          value: source[pos] === 't' ? true : false
-        })
-        pos++
+          value: source[pos] === "t" ? true : false
+        });
+        pos++;
       } else if (source[pos].match(/\n/)) {
-        line++
-        pos++
+        line++;
+        pos++;
       } else if (source[pos].match(/\s/)) {
-        pos++
+        pos++;
       } else {
-        let endPattern = /[^()"':\s]+/
+        let endPattern = /[^()"':\s]+/;
 
         if (allowSpecialCharactersInLiterals) {
-          endPattern = /[^"']+/
+          endPattern = /[^"']+/;
         }
 
-        let value = endPattern.exec(source.slice(pos))[0].trim()
+        let value = endPattern.exec(source.slice(pos))[0].trim();
 
         if (allowSpecialCharactersInLiterals) {
           tokenStream.tokens.push({
             type: tokenTypes.LITERAL,
             line: line,
-            value: value,
-          })
+            value: value
+          });
         } else {
           tokenStream.tokens.push({
             type: tokenTypes.IDENTIFIER,
             line: line,
-            value: value.trim(),
-          })
+            value: value.trim()
+          });
         }
 
-        pos += value.length
+        pos += value.length;
       }
     }
 
     tokenStream.tokens.push({
       type: tokenTypes.EOF,
-      line: line,
-    })
-    return tokenStream
+      line: line
+    });
+    return tokenStream;
   }
-}
+};

src/parser.js

-const Error = require('./Error')
+const Error = require("./Error");
 
-const AST = require('./ast')
+const AST = require("./ast");
 
-const tokenTypes = require('./tokenTypes')
+const tokenTypes = require("./tokenTypes");
 
 module.exports = class Parser {
   constructor(tokenStream) {
-    this.tokenStream = tokenStream
+    this.tokenStream = tokenStream;
   }
 
   parse() {
-    let tree = []
+    let tree = [];
     while (this.tokenStream.peek().type !== tokenTypes.EOF) {
-      tree.push(this.expr())
+      tree.push(this.expr());
       if (this.tokenStream.error) {
         return {
-          error: this.tokenStream.error,
-        }
+          error: this.tokenStream.error
+        };
       }
     }
-    return tree
+    return tree;
   }
 
   expr() {
-    let token = this.tokenStream.peek()
+    let token = this.tokenStream.peek();
     switch (token.type) {
       case tokenTypes.ATTRIBUTE:
-        return this.attribute()
+        return this.attribute();
       case tokenTypes.BOOLEAN:
-        return this.bool()
+        return this.bool();
       case tokenTypes.IDENTIFIER:
-        return this.identifier()
+        return this.identifier();
       case tokenTypes.NUMBER:
-        return this.number()
+        return this.number();
       case tokenTypes.QUOTE:
-        return this.string()
+        return this.string();
       case tokenTypes.SYMBOL:
-        return this.symbol()
+        return this.symbol();
       case tokenTypes.OPAREN:
-        return this.form()
+        return this.form();
       default:
-        this.tokenStream.error = `Unexpected ${token.type} on line ${token.line}`
+        this.tokenStream.error = `Unexpected ${token.type} on line ${
+          token.line
+        }`;
         break;
     }
   }
 
   form() {
-    this.tokenStream.eat(tokenTypes.OPAREN)
+    this.tokenStream.eat(tokenTypes.OPAREN);
 
-    let node = new AST.Application()
+    let node = new AST.Application();
 
-    node.functionName = this.identifier()
-    node.args = []
+    node.functionName = this.identifier();
+    node.args = [];
 
     while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
-      node.args.push(this.expr())
+      node.args.push(this.expr());
     }
 
-    this.tokenStream.eat(tokenTypes.CPAREN)
+    this.tokenStream.eat(tokenTypes.CPAREN);
 
-    return node
+    return node;
   }
 
   attribute() {
     return new AST.Attribute({
       name: this.tokenStream.eat(tokenTypes.ATTRIBUTE).value,
       value: this.expr()
-    })
+    });
   }
 
   bool() {
     return new AST.Boolean({
       value: this.tokenStream.eat(tokenTypes.BOOLEAN).value
-    })
+    });
   }
 
   identifier() {
     return new AST.Identifier({
       name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value
-    })
+    });
   }
 
   number() {
     return new AST.Number({
       value: this.tokenStream.eat(tokenTypes.NUMBER).value
-    })
+    });
   }
 
   string() {
-    this.tokenStream.eat(tokenTypes.QUOTE)
+    this.tokenStream.eat(tokenTypes.QUOTE);
 
-    let value = ''
+    let value = "";
 
     if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
-      value = this.tokenStream.eat(tokenTypes.LITERAL).value
+      value = this.tokenStream.eat(tokenTypes.LITERAL).value;
     }
 
     let node = new AST.String({
       value: value
-    })
+    });
 
-    this.tokenStream.eat(tokenTypes.QUOTE)
+    this.tokenStream.eat(tokenTypes.QUOTE);
 
-    return node
+    return node;
   }
 
   symbol() {
     return new AST.Symbol({
       value: this.tokenStream.eat(tokenTypes.SYMBOL).value
-    })
+    });
   }
-}
+};