yukigo 0.2.3 → 0.3.2

package/src/interpreter/utils.ts

@@ -1,84 +1,105 @@
-import {
-  Expression,
-  LazyList,
-  PrimitiveValue,
-  Environment,
-  EnvStack,
-  ASTNode,
-  isRuntimeFunction,
-  isRuntimeObject,
-  isLazyList,
-  isRuntimeClass,
-  isRuntimePredicate,
-} from "yukigo-ast";
-import { UnboundVariable } from "./errors.js";
-import { Continuation, Thunk } from "./trampoline.js";
-
-export interface ExpressionEvaluator {
-  evaluate<R = PrimitiveValue>(node: ASTNode, cont: Continuation<PrimitiveValue, R>): Thunk<R>;
-}
-
-export function createStream(
-  generator: () => Generator<PrimitiveValue, void, unknown>,
-): LazyList {
-  return {
-    type: "LazyList",
-    generator,
-  };
-}
-
-export function isArrayOfNumbers(arr: PrimitiveValue[]): arr is number[] {
-  for (const item of arr) if (typeof item !== "number") return false;
-  return true;
-}
-
-export function generateRange(
-  start: number,
-  end: number,
-  step: number,
-): number[] {
-  if (step === 0) throw new Error("Step cannot be zero in range expression");
-
-  const result: number[] = [];
-  let current = start;
-
-  if (step > 0) {
-    while (current <= end) {
-      result.push(current);
-      current += step;
-    }
-  } else {
-    while (current >= end) {
-      result.push(current);
-      current += step;
-    }
-  }
-
-  return result;
-}
-
-export function createEnv(bindings: [string, PrimitiveValue][]): Environment {
-  const env = new Map();
-  for (const [name, value] of bindings) env.set(name, value);
-  return env;
-}
-
-export function createGlobalEnv(): EnvStack {
-  return {
-    head: new Map<string, PrimitiveValue>(),
-    tail: null,
-  };
-}
-
-export function getYukigoType(val: PrimitiveValue): string {
-  if (val === null || val === undefined) return "YuNil";
-  if (typeof val === "number") return "YuNumber";
-  if (typeof val === "boolean") return "YuBoolean";
-  if (typeof val === "string") return val.length === 1 ? "YuChar" : "YuString";
-  if (Array.isArray(val) || isLazyList(val)) return "YuList";
-  if (isRuntimeFunction(val)) return "YuFunction";
-  if (isRuntimeObject(val)) return "YuObject";
-  if (isRuntimeClass(val)) return "YuClass";
-  if (isRuntimePredicate(val)) return "YuPredicate";
-  return "YuUnknown";
-}
+import { ASTNode } from "yukigo-ast";
+import {
+  BindCommand,
+  ExecutionCommand,
+  RaiseCommand,
+  StepCommand,
+} from "./components/kernel/commands.js";
+import { RuntimeContext } from "./components/RuntimeContext.js";
+import { YuValue, YuNumber, LazyList, YuBoolean } from "./primitives/index.js";
+import { InterpreterError } from "./errors.js";
+
+export const raise = (err: InterpreterError): RaiseCommand =>
+  new RaiseCommand(err);
+
+export const error = (ctx: string, msg: string): InterpreterError =>
+  new InterpreterError(ctx, msg);
+
+export const boolean = (condition: boolean) =>
+  new StepCommand(new YuBoolean(condition));
+export const number = (num: number) => {
+  const rounded = Math.round(num * 100000) / 100000;
+  return new StepCommand(new YuNumber(rounded));
+};
+
+export const not = (command: ExecutionCommand): ExecutionCommand =>
+  new BindCommand(command, (res) => res.asLogic?.not() || boolean(false));
+
+export const isTrue = (val: unknown): boolean =>
+  val instanceof YuBoolean && val.value;
+
+export const compareResult = (
+  command: ExecutionCommand,
+  predicate: (num: number) => boolean,
+): ExecutionCommand =>
+  new BindCommand(command, (res) => boolean(predicate(res.toJSON() as number)));
+
+export type NativeExtension = (
+  self: YuValue,
+  args: YuValue[],
+  ctx: RuntimeContext,
+) => ExecutionCommand;
+
+export type PrimitiveThunk = () => YuValue;
+
+export type Environment = Map<string, YuValue>;
+
+export type EnvStack = {
+  head: Environment;
+  tail: EnvStack | null;
+};
+
+export function isArrayOfNumbers(arr: YuValue): boolean {
+  const seq = arr.asSequence;
+  if (!seq) return false;
+  for (const item of seq) {
+    if (!item.asNumeric) return false;
+  }
+  return true;
+}
+
+export function generateRange(
+  start: number,
+  end: number,
+  step: number,
+): YuNumber[] {
+  if (step === 0) throw new Error("Step cannot be zero in range expression");
+
+  const result: YuNumber[] = [];
+  let current = start;
+
+  if (step > 0) {
+    while (current <= end) {
+      result.push(new YuNumber(current));
+      current += step;
+    }
+  } else {
+    while (current >= end) {
+      result.push(new YuNumber(current));
+      current += step;
+    }
+  }
+
+  return result;
+}
+
+export function createEnv(bindings: [string, YuValue][]): Environment {
+  const env = new Map<string, YuValue>();
+  for (const [name, value] of bindings) env.set(name, value);
+  return env;
+}
+
+export function createGlobalEnv(): EnvStack {
+  return {
+    head: new Map<string, YuValue>(),
+    tail: null,
+  };
+}
+
+export function getYukigoType(val: YuValue): string {
+  return val.getType();
+}
+
+export function createStream(generator: () => ExecutionCommand): LazyList {
+  return new LazyList(() => generator());
+}

package/src/tester/index.ts

@@ -1,128 +1,157 @@
-import {
-  AST,
-  Expression,
-  Test,
-  TestGroup,
-  TraverseVisitor,
-  VariablePattern,
-} from "yukigo-ast";
-import { Interpreter } from "../interpreter/index.js";
-import { FailedAssert } from "../interpreter/components/TestRunner.js";
-import { InterpreterConfig } from "../interpreter/components/RuntimeContext.js";
-
-export type TestStatus = "passed" | "failed" | "error";
-
-export interface TestReport {
-  name: string;
-  status: TestStatus;
-  message?: string;
-  duration?: number;
-  children?: TestReport[];
-}
-
-class TestExecutor extends TraverseVisitor {
-  public report: TestReport | null = null;
-  constructor(private interpreter: Interpreter) {
-    super();
-  }
-
-  visitTest(node: Test): void {
-    const name = this.evaluateName(node.name);
-    const start = Date.now();
-
-    try {
-      //this.bindParameters(node);
-      this.interpreter.evaluate(node);
-      this.report = {
-        name,
-        status: "passed",
-        duration: Date.now() - start,
-      };
-    } catch (error) {
-      this.report = this.handleError(name, start, error);
-    }
-  }
-
-  /*   private bindParameters(node: Test): void {
-    if (!node.args || node.args.length === 0) return;
-
-    for (const pattern of node.args) {
-      if (pattern instanceof VariablePattern) {
-        this.interpreter.define(pattern.name.value, null);
-      }
-    }
-  } */
-
-  visitTestGroup(node: TestGroup): void {
-    const name = this.evaluateName(node.name);
-    const start = Date.now();
-
-    try {
-      const children: TestReport[] = [];
-      for (const stmt of node.group.statements) {
-        if (stmt instanceof Test || stmt instanceof TestGroup) {
-          const visitor = new TestExecutor(this.interpreter);
-          stmt.accept(visitor);
-          if (visitor.report) children.push(visitor.report);
-        } else {
-          this.interpreter.evaluate(stmt);
-        }
-      }
-      const anyFailed = children.some((c) => c.status !== "passed");
-      this.report = {
-        name,
-        status: anyFailed ? "failed" : "passed",
-        duration: Date.now() - start,
-        children,
-      };
-    } catch (error) {
-      this.report = this.handleError(name, start, error);
-    }
-  }
-
-  private evaluateName(nameExpr: Expression): string {
-    try {
-      return String(this.interpreter.evaluate(nameExpr));
-    } catch {
-      return "Unknown Test";
-    }
-  }
-
-  private handleError(name: string, start: number, error: unknown): TestReport {
-    const duration = Date.now() - start;
-    if (error instanceof FailedAssert)
-      return { name, status: "failed", message: error.message, duration };
-
-    const message = error instanceof Error ? error.message : String(error);
-    return { name, status: "error", message, duration };
-  }
-}
-
-/**
- * The Tester class provides a high-level API for executing test nodes
- * (Tests and TestGroups) within an AST and generating a detailed report.
- */
-export class Tester {
-  constructor(
-    private ast: AST,
-    private config?: InterpreterConfig,
-  ) {}
-
-  /**
-   * Executes all Test and TestGroup nodes found at the top level of the provided AST.
-   * @param nodes The AST (or subset of nodes) to scan for tests.
-   * @returns An array of TestReport objects for each top-level test/group.
-   */
-  public test(nodes: AST): TestReport[] {
-    const reports: TestReport[] = [];
-    for (const node of nodes) {
-      if (node instanceof Test || node instanceof TestGroup) {
-        const interpreter = new Interpreter(this.ast, this.config);
-        const visitor = new TestExecutor(interpreter);
-        node.accept(visitor);
-        reports.push(visitor.report);
-      }
-    }
-    return reports;
-  }
-}
+import {
+  AST,
+  ASTNode,
+  Expression,
+  Test,
+  TestGroup,
+  TraverseVisitor,
+  VariablePattern,
+} from "yukigo-ast";
+import { Interpreter } from "../interpreter/index.js";
+import { FailedAssert } from "../interpreter/components/TestRunner.js";
+import {
+  DefaultConfiguration,
+} from "../interpreter/components/RuntimeContext.js";
+import { UnexpectedNode } from "../interpreter/errors.js";
+import { InterpreterConfig } from "../utils/helpers.js";
+
+export type TestStatus = "passed" | "failed" | "error";
+
+export interface TestReport {
+  name: string;
+  status: TestStatus;
+  message?: string;
+  duration?: number;
+  children?: TestReport[];
+}
+
+class TestExecutor extends TraverseVisitor {
+  public report: TestReport | null = null;
+
+  constructor(
+    private ast: AST,
+    private config: Partial<InterpreterConfig>,
+    private parentGroupStatements: ASTNode[] = [],
+  ) {
+    super();
+  }
+
+  visitTest(node: Test): void {
+    const interpreter = new Interpreter(this.ast, this.config);
+    for (const stmt of this.parentGroupStatements) {
+      if (!(stmt instanceof Test) && !(stmt instanceof TestGroup)) {
+        interpreter.evaluate(stmt);
+      }
+    }
+
+    const name = this.evaluateName(interpreter, node.name);
+    const start = Date.now();
+
+    try {
+      interpreter
+        .getContext()
+        .dispatchHook("beforeEachTest", interpreter, node);
+
+      interpreter.evaluate(node);
+
+      interpreter
+        .getContext()
+        .dispatchHook("afterEachTest", interpreter, node);
+
+      this.report = {
+        name,
+        status: "passed",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      this.report = this.handleError(name, start, error);
+    }
+  }
+
+  visitTestGroup(node: TestGroup): void {
+    const interpreter = new Interpreter(this.ast, this.config);
+    const name = this.evaluateName(interpreter, node.name);
+    const start = Date.now();
+
+    try {
+      const children: TestReport[] = [];
+      const nonTestStmts = node.group.statements.filter(
+        (stmt) => !(stmt instanceof Test) && !(stmt instanceof TestGroup),
+      );
+
+      for (const stmt of node.group.statements) {
+        if (stmt instanceof Test || stmt instanceof TestGroup) {
+          const visitor = new TestExecutor(
+            this.ast,
+            this.config,
+            [...this.parentGroupStatements, ...nonTestStmts],
+          );
+          stmt.accept(visitor);
+          if (visitor.report) children.push(visitor.report);
+        }
+      }
+
+      const anyFailed = children.some((c) => c.status !== "passed");
+      this.report = {
+        name,
+        status: anyFailed ? "failed" : "passed",
+        duration: Date.now() - start,
+        children,
+      };
+    } catch (error) {
+      this.report = this.handleError(name, start, error);
+    }
+  }
+
+  private evaluateName(interpreter: Interpreter, nameExpr: Expression): string {
+    try {
+      return String(interpreter.evaluate(nameExpr));
+    } catch {
+      return "Unknown Test";
+    }
+  }
+
+  private handleError(name: string, start: number, error: unknown): TestReport {
+    const duration = Date.now() - start;
+    if (error instanceof FailedAssert)
+      return { name, status: "failed", message: error.message, duration };
+
+    console.error(error);
+    const message = error instanceof Error ? error.message : String(error);
+    return { name, status: "error", message, duration };
+  }
+
+  public fallback(node: ASTNode): void {
+    throw new UnexpectedNode(node.constructor.name, "TestExecutor");
+  }
+}
+
+/**
+ * The Tester class provides a high-level API for executing test nodes
+ * (Tests and TestGroups) within an AST and generating a detailed report.
+ */
+export class Tester {
+  constructor(
+    private ast: AST,
+    private config: Partial<InterpreterConfig> = DefaultConfiguration,
+  ) {}
+
+  /**
+   * Executes all Test and TestGroup nodes found at the top level of the provided AST.
+   * @param nodes The AST (or subset of nodes) to scan for tests.
+   * @returns An array of TestReport objects for each top-level test/group.
+   */
+  public test(nodes: AST): TestReport[] {
+    const reports: TestReport[] = [];
+
+    for (const node of nodes) {
+      if (!node.is(Test) && !node.is(TestGroup)) continue;
+
+      const visitor = new TestExecutor(this.ast, this.config);
+      node.accept(visitor);
+
+      if (visitor.report) reports.push(visitor.report);
+    }
+    return reports;
+  }
+}