Implement mapping

bin/oslo.js

 
 class OsloCLI {
   constructor(opts) {
+    this.context = {}
+
+    if (opts.l) {
+      this.context = JSON.parse(fs.readFileSync(this.absolutePath(opts.l)))
+    }
+
     let output
 
     if (opts.f && opts.f !== true) {
 
   file(file) {
     const contents = fs.readFileSync(file).toString()
-    return oslo(contents)
+    return oslo(contents, this.context)
   }
 
   directory(directory) {
   }
 
   inline(source) {
-    return oslo(source)
+    return oslo(source, this.context)
   }
 
   absolutePath(file, root = null) {
 
       oslo -f index.oslo
 
+  -l The path to a json file to use as context for compilation
+
+      oslo -f index.oslo -l data.json
+
   -o Where to direct the output. If no path is provided, output will be directed
      to stdout. When used with -f, the argument should be the path to a file.
      When used with -d, the argument should be the path to a directory, which

src/compiler.js

         )
         const compiler = new Compiler(node.subtree, this.context)
         const content = compiler.compile()
-        this.result += `<${node.functionName}${
-          attributes.length ? ' ' : ''
-        }${attributes.join(' ')}>${content}</${node.functionName}>`
+
+        if (node.functionName) {
+          this.result += `<${node.functionName}${
+            attributes.length ? ' ' : ''
+          }${attributes.join(' ')}>${content}</${node.functionName}>`
+        } else {
+          this.result += content
+        }
       } else if (node.type === 'string') {
         this.result += node.content
       } else if (node.type === 'identifier') {
         this.result += this.lookup(node.name)
+      } else if (node.type === 'map') {
+        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()
+        })
       }
     })
 

src/lexer.js

           line: line,
         })
         pos++
-      } else if (source[pos].match(/['"]/)) {
+      } else if (source[pos].match(/["]/)) {
         allowSpecialCharactersInLiterals = !allowSpecialCharactersInLiterals
         tokenStream.tokens.push({
           type: tokenTypes.QUOTE,
           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()
+        tokenStream.tokens.push({
+          type: tokenTypes.SYMBOL,
+          line: line,
+          value: value,
+        })
+        pos += value.length + 1 // the +1 is to account for the apostrophe
       } else if (source[pos].match(/\n/)) {
         line++
         pos++
           endPattern = /[^"']+/
         }
 
-        let value = endPattern.exec(source.slice(pos))[0]
-        tokenStream.tokens.push({
-          type: tokenTypes.LITERAL,
-          line: line,
-          value: value.trim(),
-        })
+        let value = endPattern.exec(source.slice(pos))[0].trim()
+
+        if (['if', 'map'].includes(value)) {
+          tokenStream.tokens.push({
+            type: tokenTypes.KEYWORD,
+            line: line,
+            value: value,
+          })
+        } else {
+          tokenStream.tokens.push({
+            type: tokenTypes.LITERAL,
+            line: line,
+            value: value.trim(),
+          })
+        }
+
         pos += value.length
       }
     }

src/parser.js

         elementNode.subtree.push(this.identifier())
       } else if (this.tokenStream.peek().type === tokenTypes.QUOTE) {
         elementNode.subtree.push(this.quotedString())
+      } else if (this.tokenStream.peek().type === tokenTypes.KEYWORD) {
+        elementNode.subtree.push(this.keyword())
       }
     }
 
     })
   }
 
+  keyword() {
+    const keyword = this.tokenStream.eat(tokenTypes.KEYWORD)
+
+    if (keyword.value === 'map') {
+      const symbol = this.tokenStream.eat(tokenTypes.SYMBOL)
+      const body = this.expr()
+      const subject = this.identifier()
+      return new Node({
+        type: 'map',
+        symbol: symbol,
+        body: body,
+        subject: subject,
+      })
+    }
+  }
+
   string() {
     this.tokenStream.eat(tokenTypes.QUOTE)
     let stringValue = this.tokenStream.eat(tokenTypes.LITERAL).value

src/tokenTypes.js

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

test/compiler.js

     '<div class="foobar"><p class="bazquux">Lorem ipsum dolor sit amet.</p></div>',
   )
 })
+
+test('compiles map operations', function(t) {
+  t.plan(1)
+  const lexer = new Lexer()
+  const tokenStream = lexer.scan(`
+    (ul
+      (map 'item (li item) items))
+  `)
+  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>',
+  )
+})