sexp-template/test/parserTest.js

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

const AST = require('../src/ast')
const OsloError = require('../src/osloError')
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 (if #t "primary" "secondary")))
  `)

  t.deepEqual(tree, [
    new AST.Application({
      function: new AST.Identifier({ name: 'div', line: 2 }),
      args: [
        new AST.Attribute({
          name: 'class',
          value: new AST.String({ value: 'foobar' }),
        }),
        new AST.Application({
          function: new AST.Identifier({ name: 'p', line: 3 }),
          args: [
            new AST.Attribute({
              name: 'class',
              value: new AST.Conditional({
                condition: new AST.Boolean({ value: true }),
                ifCase: new AST.String({ value: 'primary' }),
                elseCase: 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', line: 1 }),
      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: '+', line: 1 }),
          args: [
            new AST.Identifier({ name: 'n', line: 1 }),
            new AST.Number({ value: 1, line: 1 }),
          ],
        }),
      }),
      args: [new AST.Number({ value: 5, line: 1 })],
    }),
  ])
})

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({ line: 1, name: 'do' }),
        args: [new AST.Identifier({ line: 1, name: 'this' })],
      }),
      elseCase: new AST.Application({
        function: new AST.Identifier({ line: 1, name: 'do' }),
        args: [new AST.Identifier({ line: 1, name: 'that' })],
      }),
    }),
  ])
})

test('missing close paren returns error', t => {
  t.plan(1)
  const tree = helpers.parse('(p ""')

  t.deepEqual(
    tree,
    new OsloError({
      line: 1,
      message: 'Encountered an unexpected EOF while looking for a ).',
    }),
  )
})

test('missing close quote returns an error', t => {
  t.plan(1)
  const tree = helpers.parse('(p "hello world)')

  t.deepEqual(
    tree,
    new OsloError({
      line: 1,
      message: 'Encountered an unexpected EOF while looking for a ".',
    }),
  )
})

test('allow returning atomic value from lambda', t => {
  t.plan(1)
  const tree = helpers.parse('(lambda (x) x)')

  t.deepEqual(tree, [
    new AST.Lambda({
      parameters: [new AST.Identifier({ name: 'x' })],
      body: new AST.Identifier({ name: 'x', line: 1 }),
    }),
  ])
})