yukigo 0.1.0 → 0.2.0

package/src/tester/index.ts

@@ -0,0 +1,128 @@
+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;
+  }
+}

package/src/utils/helpers.ts

@@ -1,73 +1,67 @@
-import { parseDocument } from "yaml";
-import { InspectionRule } from "../analyzer/index.js";
-import { YukigoPrimitive } from "yukigo-ast";
-
-/**
- * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
- * @param mulangYamlString The Mulang inspection syntax as a YAML string.
- * @returns An array of InspectionRule objects.
- */
-
-export class MulangAdapter {
-  public translateMulangInspection(mulangInspection: any): InspectionRule {
-    if (
-      !mulangInspection ||
-      typeof mulangInspection.inspection !== "string" ||
-      typeof mulangInspection.binding !== "string"
-    ) {
-      throw Error(
-        `Skipping malformed Mulang inspection entry: ${mulangInspection}`
-      );
-    }
-
-    const inspection: string[] = mulangInspection.inspection.split(":");
-    const expected: boolean = inspection[0] !== "Not";
-    const args: string[] = inspection.slice(expected ? 1 : 2);
-
-    return {
-      inspection: expected ? inspection[0] : inspection[1],
-      expected,
-      args,
-      binding: mulangInspection.binding,
-    };
-  }
-
-  public translateMulangExpectations(
-    mulangYamlString: string
-  ): InspectionRule[] {
-    const parsedYaml = parseDocument(mulangYamlString).toJS();
-
-    if (
-      !parsedYaml ||
-      !parsedYaml.expectations ||
-      !Array.isArray(parsedYaml.expectations)
-    ) {
-      throw Error(
-        "Invalid Mulang YAML structure. Expected 'expectations' to be an array."
-      );
-    }
-
-    const inspectionRules: InspectionRule[] = [];
-
-    for (const mulangInspection of parsedYaml.expectations) {
-      const inspection = this.translateMulangInspection(mulangInspection);
-      inspectionRules.push(inspection);
-    }
-
-    return inspectionRules;
-  }
-}
-
-export const yukigoTsMappings: { [key in YukigoPrimitive]: string } = {
-  YuNumber: "number",
-  YuString: "string",
-  YuChar: "char",
-  YuBoolean: "boolean",
-  YuNil: "null",
-  // Below some missing mappigs
-  YuList: "YuList",
-  YuObject: "YuObject",
-  YuDict: "YuDict",
-  YuTuple: "YuTuple",
-  YuSymbol: "YuSymbol",
-};
+import { parseDocument } from "yaml";
+import { InspectionRule } from "../analyzer/index.js";
+
+type MulangInspection = {
+  inspection: string;
+  binding: string;
+};
+
+const isValidFormat = (inspection: any): inspection is MulangInspection =>
+  typeof inspection === "object" &&
+  "inspection" in inspection &&
+  "binding" in inspection;
+
+/**
+ * Translates Mulang inspections (YAML format) to an array of `InspectionRule` objects.
+ * @param mulangYamlString The Mulang inspection syntax as a YAML string.
+ * @returns An array of InspectionRule objects.
+ */
+export class MulangAdapter {
+  public translateMulangInspection(mulangInspection: any): InspectionRule {
+    if (!isValidFormat(mulangInspection))
+      throw new Error(
+        `Skipping malformed Mulang inspection entry: ${mulangInspection}`
+      );
+
+    const inspection: string[] = mulangInspection.inspection.split(":");
+    const expected: boolean =
+      inspection[0] !== "Not" && inspection[0] !== "Except";
+    const args: string[] = inspection.slice(expected ? 1 : 2);
+
+    return {
+      inspection: expected ? inspection[0] : inspection[1],
+      expected,
+      args,
+      binding: mulangInspection.binding,
+    };
+  }
+
+  public translateMulangExpectations(
+    mulangYamlString: string
+  ): InspectionRule[] {
+    if (!mulangYamlString) return [];
+    const parsedYaml = parseDocument(mulangYamlString).toJS();
+
+    if (!parsedYaml) return [];
+
+    let expectations: any[] = [];
+    if (Array.isArray(parsedYaml)) {
+      expectations = parsedYaml;
+    } else if (Array.isArray(parsedYaml.expectations)) {
+      expectations = parsedYaml.expectations;
+    } else {
+      throw new Error(
+        "Invalid Mulang YAML structure. Expected 'expectations' to be an array."
+      );
+    }
+
+    const inspectionRules: InspectionRule[] = [];
+
+    for (const mulangInspection of expectations) {
+      const inspection = this.translateMulangInspection(mulangInspection);
+      inspectionRules.push(inspection);
+    }
+
+    return inspectionRules;
+  }
+}