Merge pull request #63 from thefrontside/modern-yaml-parser

migrate from `yaml-ast-parser` -> `yaml` package

Author: cowboyd

convert.ts

@@ -1,20 +1,4 @@
-import type {
-  YAMLMapping,
-  YAMLNode,
-  YAMLScalar,
-  YAMLSequence,
-} from "./deps.ts";
-import {
-  PSLiteral,
-  PSMapEntry,
-  PSMapKey,
-  PSString,
-  PSTemplate,
-  PSValue,
-} from "./types.ts";
-
-import { parseYAML } from "./deps.ts";
-import * as data from "./data.ts";
+import { PSMapEntry, PSMapKey, PSValue } from "./types.ts";
 
 /**
  * Convert a JavaScript value into a PlatformScript value
@@ -78,139 +62,3 @@ export function ps2js(value: PSValue): unknown {
       return value.value;
   }
 }
-
-/**
- * Convert source YAML into a PlatformScript Literal
- */
-export function yaml2ps(node: YAMLNode): PSLiteral<PSValue> {
-  if (node.kind === 0) { // String, Number, Boolean
-    let scalar = node as YAMLScalar;
-    if (
-      scalar.singleQuoted || scalar.doubleQuoted ||
-      typeof scalar.valueObject === "undefined"
-    ) {
-      let expressions = matchTemplate(scalar.value);
-      if (expressions.length > 0) {
-        return createLiteral({
-          type: "template",
-          value: scalar.value,
-          expressions,
-        }, node);
-      }
-      let match = matchReference(scalar.value);
-      if (match) {
-        return createLiteral({
-          type: "ref",
-          value: scalar.value,
-          key: match.key,
-          path: match.path,
-        }, node);
-      }
-      return createLiteral({
-        type: "string",
-        value: scalar.value,
-      }, node);
-    } else {
-      let value = scalar.valueObject;
-      let type = typeof scalar.valueObject;
-      if (!["number", "boolean"].includes(type)) {
-        throw new Error(`unknown scalar type: ${type}`);
-      }
-      return createLiteral({ type: type as "number" | "boolean", value }, node);
-    }
-  } else if (node.kind === 2) { // Map
-    let mappings: YAMLMapping[] = node.mappings ?? [];
-    let [first] = mappings;
-    if (!first) {
-      return { type: "map", value: new Map(), node };
-    } else {
-      let fnmatch = first.key.value.match(/^\(\s*(.*)\)\s*=>$/);
-      if (fnmatch) {
-        let param = fnmatch[1];
-        let body = yaml2ps(first.value);
-        return createLiteral({
-          type: "fn",
-          param: { name: param },
-          value: {
-            type: "platformscript",
-            body,
-          },
-        }, node);
-      } else {
-        return createLiteral({
-          type: "map",
-          value: new Map(mappings.map((m) => {
-            let value = yaml2ps(m.value);
-
-            // use method syntax
-            let mmatch = m.key.value.match(/^\s*(.+)\((.*)\)\s*$/);
-            if (mmatch) {
-              let [, key, param] = mmatch;
-              return [data.string(key), {
-                type: "fn",
-                param: { name: param },
-                value: {
-                  type: "platformscript",
-                  body: value,
-                },
-              } as PSValue];
-            } else {
-              return [yaml2ps(m.key) as PSString, value];
-            }
-          })),
-        }, node);
-      }
-    }
-  } else if (node.kind === 3) { // List
-    let list = node as YAMLSequence;
-    return createLiteral({
-      type: "list",
-      value: list.items.map(yaml2ps),
-    }, node);
-  } else {
-    console.dir({ node }, { depth: 10 });
-    throw new Error(`unknown YAMLNode of kind ${node.kind}`);
-  }
-}
-
-function matchTemplate(value: string) {
-  let valueIdx = 0;
-  let exprIdx = 1;
-  let regex = /%\(([\s\S]+?)\)/gmd;
-  let i = value.matchAll(regex);
-
-  let expressions: PSTemplate["expressions"] = [];
-
-  for (let next = i.next(); !next.done; next = i.next()) {
-    let match = next.value;
-    let expression = yaml2ps(parseYAML(match[exprIdx]));
-
-    expressions.push({
-      expression,
-
-      //@ts-expect-error RegExpMatchArray#indices not yet in the default TS lib
-      range: match.indices[valueIdx],
-    });
-  }
-  return expressions;
-}
-
-function matchReference(value: string) {
-  let pathIdx = 1;
-  let match = value.match(/^\$(\S+)$/);
-
-  if (match) {
-    let [key, ...path] = match[pathIdx].split(".");
-    return {
-      key,
-      path,
-    };
-  }
-}
-
-function createLiteral(value: PSValue, node: YAMLNode): PSLiteral {
-  return Object.defineProperty(value, "node", {
-    enumerable: false,
-    value: node,
-  }) as PSLiteral;
-}

data.ts

@@ -27,7 +27,7 @@ export function string(value: string): PSString {
 export function ref(key: string, path: string[]): PSRef {
   return {
     type: "ref",
-    value: `$${[key].concat(path).join(".")}`,
+    value: string(`$${[key].concat(path).join(".")}`),
     key,
     path,
   };

deps.ts

@@ -1,13 +1,7 @@
-export { load as parseYAML } from "https://esm.sh/yaml-ast-parser@0.0.43";
+export { default as yaml } from "https://esm.sh/yaml@2.2.1";
+export type { ParsedNode as YAMLParsedNode } from "https://esm.sh/yaml@2.2.1";
 export * from "https://raw.githubusercontent.com/cowboyd/instructional-effection/v0.0.0/mod.ts";
 export { resolve } from "https://deno.land/std@0.163.0/path/posix.ts";
-
-export type {
-  YAMLMapping,
-  YAMLNode,
-  YAMLScalar,
-  YAMLSequence,
-} from "https://esm.sh/yaml-ast-parser@0.0.43";
 export type {
   Operation,
   Task,

evaluate.ts

@@ -1,6 +1,5 @@
 import type {
   PSEnv,
-  PSFn,
   PSLiteral,
   PSMap,
   PSMapKey,
@@ -9,8 +8,8 @@ import type {
 } from "./types.ts";
 import type { Operation } from "./deps.ts";
 
-import { parseYAML } from "./deps.ts";
-import { yaml2ps } from "./convert.ts";
+import { read } from "./read.ts";
+import { recognize } from "./recognize.ts";
 import { concat, lookup, map, Maybe } from "./psmap.ts";
 import * as data from "./data.ts";
 
@@ -19,7 +18,7 @@ type Segment = {
   value: string;
 } | {
   type: "expr";
-  ref: PSLiteral;
+  ref: PSValue;
 };
 
 function* segments(t: PSTemplate): Generator<Segment> {
@@ -28,7 +27,7 @@ function* segments(t: PSTemplate): Generator<Segment> {
     let idx = 0;
     for (let expr of expressions) {
       let [start, end] = expr.range;
-      let substr = t.value.slice(idx, start);
+      let substr = t.value.value.slice(idx, start);
       yield {
         type: "const",
         value: substr,
@@ -39,16 +38,16 @@ function* segments(t: PSTemplate): Generator<Segment> {
       };
       idx = end;
     }
-    if (idx < t.value.length) {
+    if (idx < t.value.value.length) {
       yield {
         type: "const",
-        value: t.value.slice(idx),
+        value: t.value.value.slice(idx),
       };
     }
   } else {
     yield {
       type: "const",
-      value: t.value,
+      value: t.value.value,
     };
   }
 }
@@ -59,7 +58,7 @@ export function createYSEnv(parent = global): PSEnv {
       let scope = concat(parent, context);
       let env = createYSEnv(scope);
 
-      let value = yield* bind($value, scope, []);
+      let value = yield* bind(recognize($value), scope, []);
 
       if (value.type === "ref") {
         return value;
@@ -82,7 +81,7 @@ export function createYSEnv(parent = global): PSEnv {
             `${fn.value} is not a function. It is of type '${fn.type}'`,
           );
         }
-        return yield* env.call(fn, arg, rest);
+        return yield* env.call(fn, yield* env.eval(arg), rest);
       } else if (value.type === "map") {
         let entries: [PSMapKey, PSValue][] = [];
         for (let [k, v] of value.value.entries()) {
@@ -179,52 +178,8 @@ export const global: PSMap = {
   ]),
 };
 
-export function parse(source: string, filename = "script"): PSLiteral<PSValue> {
-  let yaml = parseYAML(source, { filename });
-  let [error] = yaml.errors;
-  if (!yaml) {
-    throw new SyntaxError(`empty string is not a YAML Document`);
-  } else if (error) {
-    throw error;
-  }
-  return yaml2ps(yaml);
-}
-
-export function strip(literal: PSValue): PSValue {
-  //@ts-expect-error stripping is safe because we're just dropping the node
-  let { node: _, ...value } = literal;
-  if (value.type === "map") {
-    let map = value.value;
-    return {
-      type: "map",
-      value: new Map(
-        [...map.entries()].map(([k, v]) => [strip(k) as PSMapKey, strip(v)]),
-      ),
-    };
-  } else if (value.type === "list") {
-    let list = value.value;
-    return {
-      type: "list",
-      value: list.map((val) => strip(val as PSLiteral<PSValue>)),
-    };
-  } else if (value.type === "fn" && value.value.type === "platformscript") {
-    let { body } = value.value;
-    return {
-      ...value,
-      value: {
-        type: "platformscript",
-        body: strip(body),
-      },
-    };
-  } else if (value.type === "fncall") {
-    return {
-      ...value,
-      value: strip(value.value) as PSFn,
-      arg: strip(value.arg),
-    };
-  } else {
-    return value;
-  }
+export function parse(source: string, _filename = "script"): PSValue {
+  return read(source);
 }
 
 // this is kinda cheesy. We should beef up this check.
@@ -321,44 +276,21 @@ function* bind(
     }
     return data.list(result);
   } else if (value.type === "map") {
-    let entries = [...value.value.entries()];
-    let [first, ...rest] = entries;
-
-    if (!first) {
-      //TODO: what is this for?
-      return { type: "boolean", value: false };
-    } else {
-      let [key, value] = first;
-      if (key.type === "ref") {
-        let fn = mask.includes(key.key) ? key : yield* bind(key, scope, mask);
-        if (fn.type !== "fn" && fn.type !== "ref") {
-          throw new Error(
-            `'${key.value}' is not a function, it is a ${fn.type}`,
-          );
-        }
-        return {
-          type: "fncall",
-          value: fn,
-          arg: yield* bind(value, scope, mask),
-          rest: { type: "map", value: new Map(rest) },
-        };
-      } else {
-        let $entries = [] as [PSMapKey, PSValue][];
-        for (let [k, v] of entries) {
-          $entries.push([k, yield* bind(v, scope, mask)]);
-        }
-        return {
-          type: "map",
-          value: new Map($entries),
-        };
-      }
+    let $entries = [] as [PSMapKey, PSValue][];
+    for (let [k, v] of value.value.entries()) {
+      $entries.push([k, yield* bind(v, scope, mask)]);
     }
+    return {
+      type: "map",
+      value: new Map($entries),
+    };
   } else if (value.type === "fn" && value.value.type === "platformscript") {
     let { param, value: { body } } = value;
     return {
       ...value,
       value: {
         type: "platformscript",
+        head: value.value.head,
         body: yield* bind(body, scope, mask.concat(param.name)),
       },
     };

mod.ts

@@ -1,5 +1,6 @@
 export * from "./types.ts";
 export * from "./convert.ts";
+export * from "./read.ts";
 export * from "./evaluate.ts";
 export * from "./load.ts";
 export * from "./platformscript.ts";

psmap.ts

@@ -37,10 +37,13 @@ export type Maybe<T> =
     value: void;
   };
 
-export function lookup(key: string, map: PSMap): Maybe<PSValue> {
+export function lookup(
+  key: string | number | boolean,
+  map: PSMap,
+): Maybe<PSValue> {
   for (let entry of map.value.entries()) {
     let [k, value] = entry;
-    if (k.value.toString() === key) {
+    if (k.value === key) {
       return { type: "just", value };
     }
   }