yukigo 0.1.0 → 0.2.0

package/tests/tester/Tester.spec.ts

@@ -0,0 +1,153 @@
+import { expect } from "chai";
+import {
+  Assert,
+  BooleanPrimitive,
+  Equality,
+  NumberPrimitive,
+  Sequence,
+  Test,
+  TestGroup,
+  StringPrimitive,
+  Variable,
+  SymbolPrimitive,
+  ArithmeticBinaryOperation,
+  Lambda,
+  Call,
+  Application,
+  VariablePattern,
+} from "yukigo-ast";
+import { Tester } from "../../src/tester/index.js";
+
+describe("Tester class", () => {
+  it("should run a simple passing test", () => {
+    const passingTest = new Test(
+      new StringPrimitive("Success"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(1)),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([passingTest]);
+    const results = tester.test([passingTest]);
+
+    expect(results).to.have.lengthOf(1);
+    expect(results[0].name).to.equal("Success");
+    expect(results[0].status).to.equal("passed");
+  });
+
+  it("should report a failing test with a message", () => {
+    const failingTest = new Test(
+      new StringPrimitive("Failure"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(2)),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([failingTest]);
+    const results = tester.test([failingTest]);
+
+    expect(results).to.have.lengthOf(1);
+    expect(results[0].status).to.equal("failed");
+    expect(results[0].message).to.contain("Expected 1, but got 2");
+  });
+
+  it("should run tests inside a TestGroup independently", () => {
+    const passingTest = new Test(
+      new StringPrimitive("Pass"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(10), new NumberPrimitive(10)),
+        ),
+      ]),
+    );
+
+    const failingTest = new Test(
+      new StringPrimitive("Fail"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new NumberPrimitive(1), new NumberPrimitive(0)),
+        ),
+      ]),
+    );
+
+    const group = new TestGroup(
+      new StringPrimitive("My Group"),
+      new Sequence([passingTest, failingTest]),
+    );
+
+    const tester = new Tester([group]);
+    const results = tester.test([group]);
+
+    expect(results).to.have.lengthOf(1);
+    const groupReport = results[0];
+    expect(groupReport.name).to.equal("My Group");
+    expect(groupReport.status).to.equal("failed");
+    expect(groupReport.children).to.have.lengthOf(2);
+    expect(groupReport.children![0].status).to.equal("passed");
+    expect(groupReport.children![1].status).to.equal("failed");
+  });
+
+  it("should handle setup code inside a TestGroup", () => {
+    // var x = 5
+    const setup = new Variable(
+      new SymbolPrimitive("x"),
+      new NumberPrimitive(5),
+    );
+
+    // test "Check X" { assert x == 5 }
+    const checkX = new Test(
+      new StringPrimitive("Check X"),
+      new Sequence([
+        new Assert(
+          new BooleanPrimitive(false),
+          new Equality(new SymbolPrimitive("x"), new NumberPrimitive(5)),
+        ),
+      ]),
+    );
+
+    const group = new TestGroup(
+      new StringPrimitive("Setup Group"),
+      new Sequence([setup, checkX]),
+    );
+
+    const tester = new Tester([group]);
+    const results = tester.test([group]);
+
+    expect(results[0].children).to.have.lengthOf(1);
+    expect(results[0].children![0].status).to.equal("passed");
+  });
+
+  it("should report errors that are not FailedAssert", () => {
+    // test "Error" { 1 + "a" }
+    const errorTest = new Test(
+      new StringPrimitive("Error"),
+      new Sequence([
+        new Application(
+          new Lambda(
+            [new VariablePattern(new SymbolPrimitive("b"))],
+            new ArithmeticBinaryOperation(
+              "Plus",
+              new SymbolPrimitive("b"),
+              new StringPrimitive("a"),
+            ),
+          ),
+          new NumberPrimitive(1),
+        ),
+      ]),
+    );
+
+    const tester = new Tester([errorTest]);
+    const results = tester.test([errorTest]);
+
+    expect(results[0].status).to.equal("error");
+    expect(results[0].message).to.contain("Type mismatch");
+  });
+});

package/tsconfig.build.json

@@ -1,7 +1,15 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "noEmit": false
-  },
-  "exclude": ["dist/**/*", "tests/**/*"]
-}
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false
+  },
+  "exclude": [
+    "dist/**/*",
+    "tests/**/*"
+  ],
+  "references": [
+    {
+      "path": "../yukigo-ast"
+    }
+  ],
+}

package/tsconfig.json

@@ -1,17 +1,25 @@
-{
-  "compilerOptions": {
-    "target": "es2024",
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "lib": ["es2024", "dom"],
-    "outDir": "./dist",
-    "declaration": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "include": ["**/*"],
-  "exclude": ["dist/**/*"]
-}
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "experimentalDecorators": true,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "lib": ["es2024", "dom"],
+    "outDir": "./dist",
+    "declaration": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["src"],
+  "exclude": [
+    "dist/**/*"
+  ],
+  "references": [
+    {
+      "path": "../yukigo-ast"
+    }
+  ]
+}

package/dist/analyzer/inspections/functional.d.ts

@@ -1,46 +0,0 @@
-import { ApplicationPattern, AsPattern, CompositionExpression, ConsPattern, ConstructorPattern, Fact, Function, FunctorPattern, GuardedBody, Lambda, ListComprehension, ListPattern, LiteralPattern, Rule, TraverseVisitor, TuplePattern, UnionPattern, WildcardPattern, Yield } from "@yukigo/ast";
-import { InspectionMap } from "../utils.js";
-export declare class FunctionVisitor extends TraverseVisitor {
-    private readonly targetBinding;
-    protected isInsideTargetScope: boolean;
-    constructor(binding: string);
-    visitFunction(node: Function): void;
-}
-export declare class UsesComposition extends FunctionVisitor {
-    visitCompositionExpression(node: CompositionExpression): void;
-}
-export declare class UsesAnonymousVariable extends TraverseVisitor {
-    private readonly targetBinding;
-    protected isInsideTargetScope: boolean;
-    constructor(binding: string);
-    visitWildcardPattern(node: WildcardPattern): void;
-    visitFunction(node: Function): void;
-    visitFact(node: Fact): void;
-    visitRule(node: Rule): void;
-    private enterScope;
-}
-export declare class UsesComprehension extends FunctionVisitor {
-    visitListComprehension(node: ListComprehension): void;
-}
-export declare class UsesGuards extends FunctionVisitor {
-    visitGuardedBody(node: GuardedBody): void;
-}
-export declare class UsesLambda extends FunctionVisitor {
-    visitLambda(node: Lambda): void;
-}
-export declare class UsesYield extends FunctionVisitor {
-    visitYield(node: Yield): void;
-}
-export declare class UsesPatternMatching extends FunctionVisitor {
-    visitConsPattern(node: ConsPattern): void;
-    visitAsPattern(node: AsPattern): void;
-    visitListPattern(node: ListPattern): void;
-    visitTuplePattern(node: TuplePattern): void;
-    visitLiteralPattern(node: LiteralPattern): void;
-    visitApplicationPattern(node: ApplicationPattern): void;
-    visitConstructorPattern(node: ConstructorPattern): void;
-    visitUnionPattern(node: UnionPattern): void;
-    visitFunctorPattern(node: FunctorPattern): void;
-    visitWildcardPattern(node: WildcardPattern): void;
-}
-export declare const functionalInspections: InspectionMap;

package/dist/analyzer/inspections/functional.js

@@ -1,123 +0,0 @@
-import { StopTraversalException, TraverseVisitor, } from "@yukigo/ast";
-import { executeVisitor } from "../utils.js";
-export class FunctionVisitor extends TraverseVisitor {
-    targetBinding;
-    isInsideTargetScope = false; // this flag helps to check nested functions inside the targetBinding scope
-    constructor(binding) {
-        super();
-        this.targetBinding = binding;
-    }
-    visitFunction(node) {
-        const currentFunctionName = node.identifier.value;
-        // if not inside scope then is top-level
-        if (!this.isInsideTargetScope) {
-            if (!this.targetBinding || currentFunctionName === this.targetBinding) {
-                this.isInsideTargetScope = true;
-                this.traverseCollection(node.equations);
-                this.isInsideTargetScope = false;
-                return;
-            }
-            return;
-        }
-        // if inside the scope of targetBinding then traverse
-        this.traverseCollection(node.equations);
-    }
-}
-export class UsesComposition extends FunctionVisitor {
-    visitCompositionExpression(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesAnonymousVariable extends TraverseVisitor {
-    targetBinding;
-    isInsideTargetScope = false;
-    constructor(binding) {
-        super();
-        this.targetBinding = binding;
-    }
-    visitWildcardPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitFunction(node) {
-        this.enterScope(node, node.equations);
-    }
-    visitFact(node) {
-        this.enterScope(node, node.patterns);
-    }
-    visitRule(node) {
-        this.enterScope(node, node.patterns);
-    }
-    enterScope(node, children) {
-        const nodeName = node.identifier.value;
-        if (!this.isInsideTargetScope) {
-            if (!this.targetBinding || nodeName === this.targetBinding) {
-                this.isInsideTargetScope = true;
-                this.traverseCollection(children);
-                this.isInsideTargetScope = false;
-            }
-            return;
-        }
-        this.traverseCollection(children);
-    }
-}
-export class UsesComprehension extends FunctionVisitor {
-    visitListComprehension(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesGuards extends FunctionVisitor {
-    visitGuardedBody(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesLambda extends FunctionVisitor {
-    visitLambda(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesYield extends FunctionVisitor {
-    visitYield(node) {
-        throw new StopTraversalException();
-    }
-}
-export class UsesPatternMatching extends FunctionVisitor {
-    visitConsPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitAsPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitListPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitTuplePattern(node) {
-        throw new StopTraversalException();
-    }
-    visitLiteralPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitApplicationPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitConstructorPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitUnionPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitFunctorPattern(node) {
-        throw new StopTraversalException();
-    }
-    visitWildcardPattern(node) {
-        throw new StopTraversalException();
-    }
-}
-export const functionalInspections = {
-    UsesComposition: (node, args, binding) => executeVisitor(node, new UsesComposition(binding)),
-    UsesAnonymousVariable: (node, args, binding) => executeVisitor(node, new UsesAnonymousVariable(binding)),
-    UsesComprehension: (node, args, binding) => executeVisitor(node, new UsesComprehension(binding)),
-    UsesGuards: (node, args, binding) => executeVisitor(node, new UsesGuards(binding)),
-    UsesLambda: (node, args, binding) => executeVisitor(node, new UsesLambda(binding)),
-    UsesYield: (node, args, binding) => executeVisitor(node, new UsesYield(binding)),
-    UsesPatternMatching: (node, args, binding) => executeVisitor(node, new UsesPatternMatching(binding)),
-};