Rewrite AST and compiler to be more normal

src/ast/application.js

+const Node = require('./node')
+
+module.exports = class Application extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/attribute.js

+const Node = require('./node')
+
+module.exports = class Attribute extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/boolean.js

+const Node = require('./node')
+
+module.exports = class Boolean extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/identifier.js

+const Node = require('./node')
+
+module.exports = class Identifier extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/index.js

+const Application = require('./application')
+const Attribute = require('./attribute')
+const Boolean = require('./boolean')
+const Identifier = require('./identifier')
+const Number = require('./number')
+const String = require('./string')
+const Symbol = require('./symbol')
+
+module.exports = {
+  Application: Application,
+  Attribute: Attribute,
+  Boolean: Boolean,
+  Identifier: Identifier,
+  Number: Number,
+  String: String,
+  Symbol, Symbol,
+}

src/ast/number.js

+const Node = require('./node')
+
+module.exports = class Number extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/string.js

+const Node = require('./node')
+
+module.exports = class String extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/ast/symbol.js

+const Node = require('./node')
+
+module.exports = class Symbol extends Node {
+  constructor(opts) {
+    super(opts)
+  }
+}

src/compiler.js

+const util = require('util')
+
 module.exports = class Compiler {
   constructor(tree, context) {
     this.tree = tree
     this.context = context
+    this.pos = 0
     this.result = ''
-  }
-
-  compile() {
-    const selfClosingTags = [
+    this.selfClosingTags = [
       'area',
       'base',
       'br',
       'track',
       'wbr',
     ]
+    this.standardLibrary = {
+      cond: function(predicate, left, right) {
+        if (predicate) {
+          let compiler = new Compiler([left], this.context)
+          return compiler.compile()
+        } else {
+          let compiler = new Compiler([right], this.context)
+          return compiler.compile()
+        }
+      },
+    }
+  }
 
+  compile() {
     this.tree.forEach(node => {
-      if (node.type === 'functionCall') {
-        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(' ')}>`
+      switch (node.constructor.name) {
+        case 'Application':
+          this.result += this.application(node)
+          break;
+        case 'String':
+          this.result += node.value;
+          break;
+        case 'Identifier':
+          this.result += this.lookup(node)
+          break;
+      }
+    })
 
-        if (content) {
-          this.result += content
-        }
+    return this.result
+  }
 
-        if (!selfClosingTags.includes(node.functionName)) {
-          this.result += `</${node.functionName}>`
-        }
-      } else if (node.type === 'string') {
-        this.result += node.content
-      } else if (node.type === 'identifier') {
-        this.result += this.lookup(node.name)
-      } else if (node.type === 'each') {
-        const symbol = node.symbol.value
-        const subject = this.lookup(node.subject.name)
-        subject.forEach(item => {
-          let context = {}
-          context[symbol] = item
-          const compiler = new Compiler([node.body], context)
-          this.result += compiler.compile()
-        })
-      }
+  application(node) {
+    if (this.standardLibrary[node.functionName.name]) {
+      return this.standardLibrary[node.functionName.name](...node.args)
+    }
+
+    return this.htmlElement(node)
+  }
+
+  htmlElement(node) {
+    let result = `<${node.functionName.name}`
+
+    node.args.filter(arg => arg.constructor.name === 'Attribute').forEach(arg => {
+      result += ` ${arg.name}=`
+      let compiler = new Compiler([arg.value], this.context)
+      result += `"${compiler.compile()}"`
     })
 
-    return this.result.trim()
+    result += '>'
+
+    node.args.filter(arg => arg.constructor.name !== 'Attribute').forEach(arg => {
+      let compiler = new Compiler([arg], this.context)
+      result += compiler.compile()
+    })
+
+    if (!this.selfClosingTags.includes(node.functionName.name)) {
+      result += `</${node.functionName.name}>`
+    }
+
+    return result
   }
 
-  compileAttribute(attribute) {
-    if (attribute.type === 'string') {
-      return attribute.content
-    } else if (attribute.type === 'identifier') {
-      return this.lookup(attribute.name)
+  lookup(identifier) {
+    let result = this.context[identifier.name]
+
+    if (!result) {
+      throw `Undefined variable '${identifier.name}'`
     }
+
+    return result
   }
 
-  lookup(name) {
-    return this.context[name]
+  currentNode() {
+    return this.tree[this.pos]
   }
 }

src/index.js

 const Parser = require('./parser')
 const Compiler = require('./compiler')
 
+const util = require('util')
+
 module.exports = function oslo(source, context) {
   const lexer = new Lexer()
   const tokens = lexer.scan(source)

src/lexer.js

 
         let value = endPattern.exec(source.slice(pos))[0].trim()
 
-        if (['if', 'each'].includes(value)) {
+        if (allowSpecialCharactersInLiterals) {
           tokenStream.tokens.push({
-            type: tokenTypes.KEYWORD,
+            type: tokenTypes.LITERAL,
             line: line,
             value: value,
           })
         } else {
           tokenStream.tokens.push({
-            type: tokenTypes.LITERAL,
+            type: tokenTypes.IDENTIFIER,
             line: line,
             value: value.trim(),
           })

src/parser.js

 const Error = require('./Error')
-const Node = require('./node')
+
+const AST = require('./ast')
+
 const tokenTypes = require('./tokenTypes')
 
 module.exports = class Parser {
   }
 
   expr() {
-    let node
+    let token = this.tokenStream.peek()
+    switch (token.type) {
+      case tokenTypes.ATTRIBUTE:
+        return this.attribute()
+      case tokenTypes.BOOLEAN:
+        return this.bool()
+      case tokenTypes.IDENTIFIER:
+        return this.identifier()
+      case tokenTypes.NUMBER:
+        return this.number()
+      case tokenTypes.QUOTE:
+        return this.string()
+      case tokenTypes.SYMBOL:
+        return this.symbol()
+      case tokenTypes.OPAREN:
+        return this.form()
+      default:
+        this.tokenStream.error = `Unexpected ${token.type} on line ${token.line}`
+        break;
+    }
+  }
 
+  form() {
     this.tokenStream.eat(tokenTypes.OPAREN)
 
-    while (
-      this.tokenStream.peek().type !== tokenTypes.CPAREN &&
-      this.tokenStream.peek().type !== tokenTypes.EOF
-    ) {
-      if (this.tokenStream.error) return
+    let node = new AST.Application()
 
-      if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
-        node = this.element()
-      } else if (this.tokenStream.peek().type === tokenTypes.KEYWORD) {
-        node = this.keyword()
-      }
+    node.functionName = this.identifier()
+    node.args = []
+
+    while (this.tokenStream.peek().type !== tokenTypes.CPAREN) {
+      node.args.push(this.expr())
     }
 
     this.tokenStream.eat(tokenTypes.CPAREN)
     return node
   }
 
-  element() {
-    let elementNode = new Node({
-      type: 'functionCall',
-      args: [],
-      subtree: [],
-      functionName: this.tokenStream.eat(tokenTypes.LITERAL).value,
+  attribute() {
+    return new AST.Attribute({
+      name: this.tokenStream.eat(tokenTypes.ATTRIBUTE).value,
+      value: this.expr()
     })
-
-    while (
-      ![tokenTypes.CPAREN, tokenTypes.EOF].includes(
-        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) {
-        elementNode.subtree.push(this.quotedString())
-      } else if (this.tokenStream.peek().type === tokenTypes.OPAREN) {
-        elementNode.subtree.push(this.expr())
-      } else if (this.tokenStream.peek().type === tokenTypes.LITERAL) {
-        elementNode.subtree.push(this.identifier())
-      }
-    }
-
-    return elementNode
   }
 
-  attribute() {
-    let attributeNode = new Node()
-    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) {
-      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
+  bool() {
+    return new AST.Boolean({
+      value: this.tokenStream.eat(tokenTypes.BOOLEAN).value
+    })
   }
 
   identifier() {
-    const identifier = this.tokenStream.eat(tokenTypes.LITERAL)
-    return new Node({
-      type: 'identifier',
-      name: identifier.value,
+    return new AST.Identifier({
+      name: this.tokenStream.eat(tokenTypes.IDENTIFIER).value
     })
   }
 
-  quotedString() {
-    return new Node({
-      type: 'string',
-      content: this.string(),
+  number() {
+    return new AST.Number({
+      value: this.tokenStream.eat(tokenTypes.NUMBER).value
     })
   }
 
-  keyword() {
-    const keyword = this.tokenStream.eat(tokenTypes.KEYWORD)
-
-    if (keyword.value === 'each') {
-      const subject = this.identifier()
-      const symbol = this.tokenStream.eat(tokenTypes.SYMBOL)
-      const body = this.expr()
-      return new Node({
-        type: 'each',
-        symbol: symbol,
-        body: body,
-        subject: subject,
-      })
-    }
-  }
-
   string() {
     this.tokenStream.eat(tokenTypes.QUOTE)
-    let stringValue = this.tokenStream.eat(tokenTypes.LITERAL).value
+    let node = new AST.String({
+      value: this.tokenStream.eat(tokenTypes.LITERAL).value
+    })
     this.tokenStream.eat(tokenTypes.QUOTE)
-    return stringValue
+    return node
+  }
+
+  symbol() {
+    return new AST.Symbol({
+      value: this.tokenStream.eat(tokenTypes.SYMBOL).value
+    })
   }
 }

src/tokenTypes.js

   SYMBOL: 'symbol',
   NUMBER: 'number',
   BOOLEAN: 'boolean',
+  IDENTIFIER: 'identifier',
   EOF: 'EOF',
 }

test/compiler.js

 
 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 map operations', function(t) {
-  t.plan(1)
-  const lexer = new Lexer()
-  const tokenStream = lexer.scan(`
-    (ul
-      (each items 'item (li item)))
-  `)
-  const parser = new Parser(tokenStream)
-  const tree = parser.parse()
-  const compiler = new Compiler(tree, {
-    items: ['one', 'two', 'three'],
-  })
-  const result = compiler.compile()
-  t.deepEqual(
-    result.replace(/\n/g, '').replace(/  +/g, ''),
-    '<ul><li>one</li><li>two</li><li>three</li></ul>',
-  )
-})
-
 test('self closing tags are respected', function(t) {
   t.plan(1)
   const lexer = new Lexer()

test/lexer.js

   ).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
-    tt.LITERAL,
+    tt.IDENTIFIER,
     tt.ATTRIBUTE,
     tt.QUOTE,
     tt.LITERAL,
     tt.QUOTE,
     tt.OPAREN,
-    tt.LITERAL,
+    tt.IDENTIFIER,
     tt.QUOTE,
     tt.LITERAL,
     tt.QUOTE,
   let tokens = lexer.scan(`(test test test)`).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
-    tt.LITERAL,
-    tt.LITERAL,
-    tt.LITERAL,
+    tt.IDENTIFIER,
+    tt.IDENTIFIER,
+    tt.IDENTIFIER,
     tt.CPAREN,
     tt.EOF,
   ])
   tokens = lexer.scan(`(test "test" test test)`).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
-    tt.LITERAL,
+    tt.IDENTIFIER,
     tt.QUOTE,
     tt.LITERAL,
     tt.QUOTE,
-    tt.LITERAL,
-    tt.LITERAL,
+    tt.IDENTIFIER,
+    tt.IDENTIFIER,
     tt.CPAREN,
     tt.EOF,
   ])
   `).tokens
   t.deepEqual(tokens.map(token => token.type), [
     tt.OPAREN,
-    tt.LITERAL,
+    tt.IDENTIFIER,
     tt.QUOTE,
     tt.LITERAL,
     tt.QUOTE,

test/parser.js

 const test = require('tape')
 
 const Lexer = require('../src/lexer')
-const Node = require('../src/node')
+const AST = require('../src/ast/index')
 const Parser = require('../src/parser')
 const tt = require('../src/tokenTypes')
 
   const lexer = new Lexer()
   let tokenStream = lexer.scan(`
     (div :class "foobar"
-      (p :class "bazquux"))
+      (p :class (cond #t "primary" "secondary")))
   `)
   let parser = new Parser(tokenStream)
   let tree = parser.parse()
 
   t.deepEqual(tree, [
-    new Node({
-      type: 'functionCall',
-      functionName: 'div',
+    new AST.Application({
+      functionName: new AST.Identifier({ name: 'div' }),
       args: [
-        new Node({
-          attributeName: 'class',
-          attributeValue: new Node({ type: 'string', content: 'foobar' }),
+        new AST.Attribute({
+          name: 'class',
+          value: new AST.String({ value: 'foobar' })
         }),
-      ],
-      subtree: [
-        new Node({
-          type: 'functionCall',
-          functionName: 'p',
+        new AST.Application({
+          functionName: new AST.Identifier({ name: 'p' }),
           args: [
-            new Node({
-              attributeName: 'class',
-              attributeValue: new Node({ type: 'string', content: 'bazquux' }),
-            }),
-          ],
-          subtree: [],
-        }),
-      ],
-    }),
+            new AST.Attribute({
+              name: 'class',
+              value: new AST.Application({
+                functionName: new AST.Identifier({ name: 'cond' }),
+                args: [
+                  new AST.Boolean({ value: true }),
+                  new AST.String({ value: 'primary' }),
+                  new AST.String({ value: 'secondary' }),
+                ]
+              })
+            })
+          ]
+        })
+      ]
+    })
   ])
 })
-
-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.',
-  })
-})