sexp-template/test/parserTest.js

const test = require('tape')
const helpers = require('./helpers')

const AST = require('../src/ast/index')
const tt = require('../src/tokenTypes')

test('parses token stream into a tree', t => {
  t.plan(1)
  const tree = helpers.parse(`
    (div :class "foobar"
      (p :class (cond #t "primary" "secondary")))
  `)

  t.deepEqual(tree, [
    new AST.Application({
      function: new AST.Identifier({ name: 'div' }),
      args: [
        new AST.Attribute({
          name: 'class',
          value: new AST.String({ value: 'foobar' }),
        }),
        new AST.Application({
          function: new AST.Identifier({ name: 'p' }),
          args: [
            new AST.Attribute({
              name: 'class',
              value: new AST.Application({
                function: new AST.Identifier({ name: 'cond' }),
                args: [
                  new AST.Boolean({ value: true }),
                  new AST.String({ value: 'primary' }),
                  new AST.String({ value: 'secondary' }),
                ],
              }),
            }),
          ],
        }),
      ],
    }),
  ])
})

test('allow empty strings', t => {
  t.plan(1)
  const tree = helpers.parse('(p "")')

  t.deepEqual(tree, [
    new AST.Application({
      function: new AST.Identifier({ name: 'p' }),
      args: [new AST.String({ value: '' })],
    }),
  ])
})

test('parse lambdas and expressions in function position', t => {
  t.plan(1)
  const tree = helpers.parse('((lambda (n) (+ n 1)) 5)')

  t.deepEqual(tree, [
    new AST.Application({
      function: new AST.Lambda({
        parameters: [new AST.Identifier({ name: 'n' })],
        body: new AST.Application({
          function: new AST.Identifier({ name: '+' }),
          args: [
            new AST.Identifier({ name: 'n' }),
            new AST.Number({ value: 1 }),
          ],
        }),
      }),
      args: [new AST.Number({ value: 5 })],
    }),
  ])
})

test('parse conditionals', t => {
  t.plan(1)
  const tree = helpers.parse('(if #t (do this) (do that))')

  t.deepEqual(tree, [
    new AST.Conditional({
      condition: new AST.Boolean({ value: true }),
      ifCase: new AST.Application({
        function: new AST.Identifier({ name: 'do' }),
        args: [
          new AST.Identifier({ name: 'this' })
        ]
      }),
      elseCase: new AST.Application({
        function: new AST.Identifier({ name: 'do' }),
        args: [
          new AST.Identifier({ name: 'that' })
        ]
      }),
    })
  ])
})