fix(let): refactor let

src/askvm/resources/core/__test__/assign.test.ts

@@ -0,0 +1,53 @@
+import { runUntyped } from '../../..';
+import { parse } from '../../../../askcode';
+import * as core from '../../core';
+import { assignRes } from '../assign';
+
+const values = {};
+
+function ask(code: string) {
+  return runUntyped(
+    {
+      resources: { ...core, assignRes },
+      values,
+    },
+    parse(code)
+  );
+}
+
+describe(`assign`, function () {
+  it(`Should assign a value to a 'let' variable with the assign resource.`, async function () {
+    const initialValue = 6;
+    const assignedValue = 4;
+    const resolvedValue = await ask(
+      `ask(let('a',${initialValue}),assign('a',${assignedValue}))`
+    );
+    expect(resolvedValue).toEqual(assignedValue);
+  });
+
+  it(`Should throw when assigning a value to a constant variable.`, async function () {
+    const constantName = 'favoriteConst';
+    await expect(
+      ask(
+        `ask(const('${constantName}','Coconut'),assign('${constantName}','Wallnut'))`
+      )
+    ).rejects.toThrow(
+      `Cannot assign to a constant variable "${constantName}" because it is a constant.`
+    );
+  });
+
+  it(`Should throw when assigning a value to a non-declared variable.`, async function () {
+    await expect(ask(`ask(assign('unrealisticCoco','Nut'))`)).rejects.toThrow(
+      `Cannot assign to an unknown variable "unrealisticCoco"`
+    );
+  });
+
+  it(`Should throw when assigning a value to a reserved keyword variable.`, async function () {
+    const reservedWord = 'resources';
+    await expect(
+      ask(`ask(assign('${reservedWord}','CocoResource'))`)
+    ).rejects.toThrow(
+      `Key "resources" is a reserved keyword and cannot be assigned to.`
+    );
+  });
+});

src/askvm/resources/core/__test__/const.test.ts

@@ -0,0 +1,44 @@
+import { runUntyped } from '../../..';
+import { parse } from '../../../../askcode';
+import * as core from '../../core';
+import { constRes } from '../const';
+
+const values = {};
+
+function ask(code: string) {
+  return runUntyped(
+    {
+      resources: { ...core, constRes },
+      values,
+    },
+    parse(code)
+  );
+}
+
+describe(`const`, function () {
+  it(`should assign value to a const variable on initialization`, async function () {
+    const value = 6;
+    await expect(
+      ask(`ask(const('a',${value}),call(get('get'), 'a'))`)
+    ).resolves.toEqual(value);
+  });
+
+  it(`Creating a const should create a Javascript variable object which is Object.isFrozen()`, async function () {
+    const value = 6;
+    const constantVariable = await expect(
+      ask(`ask(const('a',${value}),call(get('get'), 'a'))`)
+    ).resolves.toEqual(value);
+    expect(Object.isFrozen(constantVariable)).toBe(true);
+  });
+
+  const reservedWords = ['resources'];
+
+  it(`should not allow reserved words as constant name`, async function () {
+    for (let i = 0; i < reservedWords.length; i++) {
+      const reservedWord = reservedWords[i];
+      await expect(ask(`ask(const('resources',6))`)).rejects.toThrow(
+        `Key "${reservedWord}" cannot be redeclared`
+      );
+    }
+  });
+});

src/askvm/resources/core/__test__/let.test.ts

@@ -16,29 +16,13 @@ function ask(code: string) {
 }
 
 describe(`let`, function () {
-  it(`should throw when trying to assign to const`, async function () {
+  it(`should assign value to a let variable on initialization`, async function () {
     const value = 6;
     await expect(
-      ask(`ask(const('a',${value}),call(get('get'),assign('a',4),'a'))`)
-    ).rejects.toThrow(`Cannot assign to a constant variable "a"`);
-  });
-
-  it(`should assign value on initialization`, async function () {
-    const value = 6;
-    await expect(
-      ask(`ask(let('a',${value}),call(get('get'), 'a'))`)
+      ask(`ask(let('cocoCount',${value}),get('cocoCount'))`)
     ).resolves.toEqual(value);
   });
 
-  it(`should assign value with the assign resource`, async function () {
-    const initialValue = 6;
-    const assignedValue = 4;
-    const resolvedValue = await ask(
-      `ask(let('a',${initialValue}),assign('a',${assignedValue}))`
-    );
-    expect(resolvedValue).toEqual(assignedValue);
-  });
-
   const reservedWords = ['resources'];
 
   it(`should not allow reserved words as variable name`, async function () {

src/askvm/resources/core/assign.ts

@@ -0,0 +1,57 @@
+import {
+  any,
+  resource,
+  run,
+  runUntyped,
+  Options,
+  TypedValue,
+  JSONable,
+} from '../../lib';
+
+function assignValue(
+  valueObject: { [key: string]: any },
+  key: string,
+  assignedValue: any
+) {
+  if (Object.isFrozen(valueObject[key]))
+    throw new Error(
+      `Cannot assign to a constant variable "${key}" because it is a constant.`
+    );
+  valueObject[key] = assignedValue;
+}
+
+export const assignRes = resource({
+  type: any,
+  async compute(options, code, args): Promise<TypedValue<JSONable>> {
+    const { params: children = [] } = code;
+
+    const key: any = await runUntyped(options, children[0]); // FIXME any
+    const value = await run(options, children[1]);
+
+    if (key === 'resources') {
+      throw new Error(
+        `Key "resources" is a reserved keyword and cannot be assigned to.`
+      );
+    }
+
+    let keyFound = false;
+    for (
+      let prototype: Options | undefined = options;
+      prototype;
+      prototype = prototype?.prototype
+    ) {
+      const { values = {} } = prototype;
+      if (Object.prototype.hasOwnProperty.call(values, key)) {
+        assignValue(values, key, value);
+        keyFound = true;
+        return value;
+      }
+    }
+    if (keyFound === false)
+      throw new Error(`Cannot assign to an unknown variable "${key}"`);
+
+    options.values![key] = value;
+
+    return value;
+  },
+});

src/askvm/resources/core/const.ts

@@ -0,0 +1,25 @@
+import {
+  any,
+  resource,
+  run,
+  runUntyped,
+  TypedValue,
+  JSONable,
+} from '../../lib';
+
+export const constRes = resource({
+  type: any,
+  async compute(options, code, args): Promise<TypedValue<JSONable>> {
+    const { params: children = [] } = code;
+
+    const key: any = await runUntyped(options, children[0]); // FIXME any
+    const value = await run(options, children[1]);
+
+    if (key === 'resources') {
+      throw new Error(`Key "resources" cannot be redeclared`);
+    }
+    options.values![key] = value;
+    Object.freeze(options.values![key]);
+    return value;
+  },
+});

src/askvm/resources/core/index.ts

@@ -22,7 +22,9 @@ export * from './fun';
 export * from './get';
 export { ifRes as if } from './if';
 export * from './is';
-export { letRes as let, letRes as const, letRes as assign } from './let';
+export { letRes as let } from './let';
+export { constRes as const } from './const';
+export { assignRes as assign } from './assign';
 export * from './list';
 export * from './logicalOr';
 export * from './not';

src/askvm/resources/core/let.ts

@@ -30,26 +30,8 @@ export const letRes = resource({
       throw new Error(`Key "resources" cannot be redeclared`);
     }
 
-    if (code.name === 'assign') {
-      for (
-        let prototype: Options | undefined = options;
-        prototype;
-        prototype = prototype?.prototype
-      ) {
-        const { values = {} } = prototype;
-        if (Object.prototype.hasOwnProperty.call(values, key)) {
-          assignValue(values, key, value);
-          return value;
-        }
-      }
-      throw new Error(`Cannot assign to an unknown variable "${key}"`);
-    }
-
     options.values![key] = value;
 
-    if (code.name === 'const') {
-      Object.freeze(options.values![key]);
-    }
     return value;
   },
 });