modeling-app/src/lang/executor.test.ts

import fs from 'node:fs'

import {
  parse,
  ProgramMemory,
  SketchGroup,
  initPromise,
  sketchGroupFromKclValue,
} from './wasm'
import { enginelessExecutor } from '../lib/testHelpers'
import { KCLError } from './errors'

beforeAll(async () => {
  await initPromise
})

describe('test executor', () => {
  it('test assigning two variables, the second summing with the first', async () => {
    const code = `const myVar = 5
const newVar = myVar + 1`
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(5)
    expect(mem.get('newVar')?.value).toBe(6)
  })
  it('test assigning a var with a string', async () => {
    const code = `const myVar = "a str"`
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe('a str')
  })
  it('test assigning a var by cont concatenating two strings string execute', async () => {
    const code = fs.readFileSync(
      './src/lang/testExamples/variableDeclaration.cado',
      'utf-8'
    )
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe('a str another str')
  })
  it('fn funcN = () => {} execute', async () => {
    const mem = await exe(
      [
        'fn funcN = (a, b) => {',
        '  return a + b',
        '}',
        'const theVar = 60',
        'const magicNum = funcN(9, theVar)',
      ].join('\n')
    )
    expect(mem.get('theVar')?.value).toBe(60)
    expect(mem.get('magicNum')?.value).toBe(69)
  })
  it('sketch declaration', async () => {
    let code = `const mySketch = startSketchOn('XY')
  |> startProfileAt([0,0], %)
  |> lineTo([0,2], %, $myPath)
  |> lineTo([2,3], %)
  |> lineTo([5,-1], %, $rightPath)
  // |> close(%)
`
    const mem = await exe(code)
    // geo is three js buffer geometry and is very bloated to have in tests
    const minusGeo = mem.get('mySketch')?.value?.value
    expect(minusGeo).toEqual([
      {
        type: 'ToPoint',
        to: [0, 2],
        from: [0, 0],
        __geoMeta: {
          sourceRange: [72, 97],
          id: expect.any(String),
        },
        tag: {
          end: 96,
          start: 89,
          type: 'TagDeclarator',
          value: 'myPath',
          digest: null,
        },
      },
      {
        type: 'ToPoint',
        to: [2, 3],
        from: [0, 2],
        tag: null,
        __geoMeta: {
          sourceRange: [103, 119],
          id: expect.any(String),
        },
      },
      {
        type: 'ToPoint',
        to: [5, -1],
        from: [2, 3],
        __geoMeta: {
          sourceRange: [125, 154],
          id: expect.any(String),
        },
        tag: {
          end: 153,
          start: 143,
          type: 'TagDeclarator',
          value: 'rightPath',
          digest: null,
        },
      },
    ])
  })

  it('pipe binary expression into call expression', async () => {
    const code = [
      'fn myFn = (a) => { return a + 1 }',
      'const myVar = 5 + 1 |> myFn(%)',
    ].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(7)
  })

  // Enable rotations #152
  // it('rotated sketch', async () => {
  //   const code = [
  //     'const mySk1 = startSketchAt([0,0])',
  //     '  |> lineTo([1,1], %)',
  //     '  |> lineTo([0, 1], %, "myPath")',
  //     '  |> lineTo([1, 1], %)',
  //     'const rotated = rx(90, mySk1)',
  //   ].join('\n')
  //   const mem = await exe(code)
  //   expect(mem.get('mySk1')?.value).toHaveLength(3)
  //   expect(mem.get('rotated')?.type).toBe('SketchGroup')
  //   if (
  //     mem.get('mySk1')?.type !== 'SketchGroup' ||
  //     mem.get('rotated')?.type !== 'SketchGroup'
  //   )
  //     throw new Error('not a sketch group')
  //   expect(mem.get('mySk1')?.rotation).toEqual([0, 0, 0, 1])
  //   expect(mem.get('rotated')?.rotation.map((a) => a.toFixed(4))).toEqual([
  //     '0.7071',
  //     '0.0000',
  //     '0.0000',
  //     '0.7071',
  //   ])
  // })

  it('execute pipe sketch into call expression', async () => {
    // Enable rotations #152
    const code = [
      "const mySk1 = startSketchOn('XY')",
      '  |> startProfileAt([0,0], %)',
      '  |> lineTo([1,1], %)',
      '  |> lineTo([0, 1], %, $myPath)',
      '  |> lineTo([1,1], %)',
      // '  |> rx(90, %)',
    ].join('\n')
    const mem = await exe(code)
    expect(mem.get('mySk1')).toEqual({
      type: 'UserVal',
      value: {
        type: 'SketchGroup',
        on: expect.any(Object),
        start: {
          to: [0, 0],
          from: [0, 0],
          tag: null,
          __geoMeta: {
            id: expect.any(String),
            sourceRange: [39, 63],
          },
        },
        tags: {
          myPath: {
            __meta: [
              {
                sourceRange: [109, 116],
              },
            ],
            type: 'TagIdentifier',
            value: 'myPath',
            info: expect.any(Object),
          },
        },
        value: [
          {
            type: 'ToPoint',
            to: [1, 1],
            from: [0, 0],
            tag: null,
            __geoMeta: {
              sourceRange: [69, 85],
              id: expect.any(String),
            },
          },
          {
            type: 'ToPoint',
            to: [0, 1],
            from: [1, 1],
            __geoMeta: {
              sourceRange: [91, 117],
              id: expect.any(String),
            },
            tag: {
              end: 116,
              start: 109,
              type: 'TagDeclarator',
              value: 'myPath',
              digest: null,
            },
          },
          {
            type: 'ToPoint',
            to: [1, 1],
            from: [0, 1],
            tag: null,
            __geoMeta: {
              sourceRange: [123, 139],
              id: expect.any(String),
            },
          },
        ],
        id: expect.any(String),
        __meta: [{ sourceRange: [39, 63] }],
      },
      __meta: [{ sourceRange: [39, 63] }],
    })
  })
  it('execute array expression', async () => {
    const code = ['const three = 3', "const yo = [1, '2', three, 4 + 5]"].join(
      '\n'
    )
    const mem = await exe(code)
    // TODO path to node is probably wrong here, zero indexes are not correct
    expect(mem.get('three')).toEqual({
      type: 'UserVal',
      value: 3,
      __meta: [
        {
          sourceRange: [14, 15],
        },
      ],
    })
    expect(mem.get('yo')).toEqual({
      type: 'UserVal',
      value: [1, '2', 3, 9],
      __meta: [
        {
          sourceRange: [27, 49],
        },
      ],
    })
    // Check that there are no other variables or environments.
    expect(mem.numEnvironments()).toBe(1)
    expect(mem.numVariables(0)).toBe(2)
  })
  it('execute object expression', async () => {
    const code = [
      'const three = 3',
      "const yo = {aStr: 'str', anum: 2, identifier: three, binExp: 4 + 5}",
    ].join('\n')
    const mem = await exe(code)
    expect(mem.get('yo')).toEqual({
      type: 'UserVal',
      value: { aStr: 'str', anum: 2, identifier: 3, binExp: 9 },
      __meta: [
        {
          sourceRange: [27, 83],
        },
      ],
    })
  })
  it('execute memberExpression', async () => {
    const code = ["const yo = {a: {b: '123'}}", "const myVar = yo.a['b']"].join(
      '\n'
    )
    const mem = await exe(code)
    expect(mem.get('myVar')).toEqual({
      type: 'UserVal',
      value: '123',
      __meta: [
        {
          sourceRange: [41, 50],
        },
      ],
    })
  })
})

describe('testing math operators', () => {
  it('can sum', async () => {
    const code = ['const myVar = 1 + 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(3)
  })
  it('can subtract', async () => {
    const code = ['const myVar = 1 - 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(-1)
  })
  it('can multiply', async () => {
    const code = ['const myVar = 1 * 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(2)
  })
  it('can divide', async () => {
    const code = ['const myVar = 1 / 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(0.5)
  })
  it('can modulus', async () => {
    const code = ['const myVar = 5 % 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(1)
  })
  it('can do multiple operations', async () => {
    const code = ['const myVar = 1 + 2 * 3'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(7)
  })
  it('big example with parans', async () => {
    const code = ['const myVar = 1 + 2 * (3 - 4) / -5 + 6'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(7.4)
  })
  it('with identifier', async () => {
    const code = ['const yo = 6', 'const myVar = yo / 2'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(3)
  })
  it('with lots of testing', async () => {
    const code = ['const myVar = 2 * ((2 + 3 ) / 4 + 5)'].join('\n')
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(12.5)
  })
  it('with callExpression at start', async () => {
    const code = 'const myVar = min(4, 100) + 2'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(6)
  })
  it('with callExpression at end', async () => {
    const code = 'const myVar = 2 + min(4, 100)'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(6)
  })
  it('with nested callExpression', async () => {
    const code = 'const myVar = 2 + min(100, legLen(5, 3))'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(6)
  })
  it('with unaryExpression', async () => {
    const code = 'const myVar = -min(100, 3)'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(-3)
  })
  it('with unaryExpression in callExpression', async () => {
    const code = 'const myVar = min(-legLen(5, 4), 5)'
    const code2 = 'const myVar = min(5 , -legLen(5, 4))'
    const mem = await exe(code)
    const mem2 = await exe(code2)
    expect(mem.get('myVar')?.value).toBe(-3)
    expect(mem.get('myVar')?.value).toBe(mem2.get('myVar')?.value)
  })
  it('with unaryExpression in ArrayExpression', async () => {
    const code = 'const myVar = [1,-legLen(5, 4)]'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toEqual([1, -3])
  })
  it('with unaryExpression in ArrayExpression in CallExpression, checking nothing funny happens when used in a sketch', async () => {
    const code = [
      "const part001 = startSketchOn('XY')",
      '  |> startProfileAt([0, 0], %)',
      '|> line([-2.21, -legLen(5, min(3, 999))], %)',
    ].join('\n')
    const mem = await exe(code)
    const sketch = sketchGroupFromKclValue(mem.get('part001'), 'part001')
    // result of `-legLen(5, min(3, 999))` should be -4
    const yVal = (sketch as SketchGroup).value?.[0]?.to?.[1]
    expect(yVal).toBe(-4)
  })
  it('test that % substitution feeds down CallExp->ArrExp->UnaryExp->CallExp', async () => {
    const code = [
      `const myVar = 3`,
      `const part001 = startSketchOn('XY')`,
      `  |> startProfileAt([0, 0], %)`,
      `  |> line([3, 4], %, $seg01)`,
      `  |> line([`,
      `  min(segLen(seg01), myVar),`,
      `  -legLen(segLen(seg01), myVar)`,
      `], %)`,
      ``,
    ].join('\n')
    const mem = await exe(code)
    const sketch = sketchGroupFromKclValue(mem.get('part001'), 'part001')
    // expect -legLen(segLen('seg01'), myVar) to equal -4 setting the y value back to 0
    expect((sketch as SketchGroup).value?.[1]?.from).toEqual([3, 4])
    expect((sketch as SketchGroup).value?.[1]?.to).toEqual([6, 0])
    const removedUnaryExp = code.replace(
      `-legLen(segLen(seg01), myVar)`,
      `legLen(segLen(seg01), myVar)`
    )
    const removedUnaryExpMem = await exe(removedUnaryExp)
    const removedUnaryExpMemSketch = sketchGroupFromKclValue(
      removedUnaryExpMem.get('part001'),
      'part001'
    )

    // without the minus sign, the y value should be 8
    expect((removedUnaryExpMemSketch as SketchGroup).value?.[1]?.to).toEqual([
      6, 8,
    ])
  })
  it('with nested callExpression and binaryExpression', async () => {
    const code = 'const myVar = 2 + min(100, -1 + legLen(5, 3))'
    const mem = await exe(code)
    expect(mem.get('myVar')?.value).toBe(5)
  })
  it('can do power of math', async () => {
    const code = 'const myNeg2 = 4 ^ 2 - 3 ^ 2 * 2'
    const mem = await exe(code)
    expect(mem.get('myNeg2')?.value).toBe(-2)
  })
})

describe('Testing Errors', () => {
  it('should throw an error when a variable is not defined', async () => {
    const code = `const myVar = 5
const theExtrude = startSketchOn('XY')
  |> startProfileAt([0, 0], %)
  |> line([-2.4, 5], %)
  |> line([-0.76], myVarZ, %)
  |> line([5,5], %)
  |> close(%)
  |> extrude(4, %)`
    await expect(exe(code)).rejects.toEqual(
      new KCLError(
        'undefined_value',
        'memory item key `myVarZ` is not defined',
        [[129, 135]]
      )
    )
  })
})

// helpers

async function exe(
  code: string,
  programMemory: ProgramMemory = ProgramMemory.empty()
) {
  const ast = parse(code)

  const result = await enginelessExecutor(ast, programMemory)
  return result
}