yukigo 0.1.0

package/src/utils/helpers.ts

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

package/tests/analyzer/functional.spec.ts

@@ -0,0 +1,221 @@
+import { expect } from "chai";
+import {
+  Function,
+  Equation,
+  SymbolPrimitive,
+  UnguardedBody,
+  GuardedBody,
+  Sequence,
+  CompositionExpression,
+  Lambda,
+  Application,
+  ListComprehension,
+  Yield,
+  LiteralPattern,
+  ListPattern,
+  WildcardPattern,
+  BooleanPrimitive,
+  NumberPrimitive,
+  If,
+} from "yukigo-ast";
+import {
+  UsesComposition,
+  UsesAnonymousVariable,
+  UsesComprehension,
+  UsesGuards,
+  UsesLambda,
+  UsesYield,
+  UsesPatternMatching,
+} from "../../src/analyzer/inspections/functional.js";
+import { executeVisitor } from "../../src/analyzer/utils.js";
+
+describe("Functional Spec", () => {
+  const createSymbol = (name: string) => new SymbolPrimitive(name);
+  const createSequence = (expr: any) => new Sequence([expr]);
+  const createEquation = (patterns: any[], bodyExpr: any) => {
+    const body = Array.isArray(bodyExpr)
+      ? bodyExpr
+      : new UnguardedBody(createSequence(bodyExpr));
+
+    return new Equation(patterns, body, undefined);
+  };
+  const createFunction = (name: string, equations: Equation[]) => {
+    return new Function(createSymbol(name), equations);
+  };
+  const mockExpr = new NumberPrimitive(1);
+
+  describe("UsesGuards", () => {
+    it("detects guards when they are present", () => {
+      const guardedBody = new GuardedBody(mockExpr, mockExpr);
+      const equation = new Equation([], [guardedBody, guardedBody], undefined);
+      const func = createFunction("f", [equation]);
+
+      const visitor = new UsesGuards("f");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("does not detect guards when using UnguardedBody", () => {
+      const equation = createEquation([], mockExpr);
+      const func = createFunction("f", [equation]);
+
+      const visitor = new UsesGuards("f");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+
+    it("should respect binding scope", () => {
+      const guardedBody = new GuardedBody(mockExpr, mockExpr);
+      const equation = new Equation([], [guardedBody], undefined);
+      const func = createFunction("g", [equation]);
+
+      const visitor = new UsesGuards("f");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesComposition", () => {
+    const createComp = () => new CompositionExpression(mockExpr, mockExpr);
+
+    it("is True when composition is present on top level", () => {
+      const func = createFunction("x", [createEquation([], createComp())]);
+
+      const visitor = new UsesComposition("x");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True when composition is present inside lambda", () => {
+      const lambda = new Lambda([], createComp());
+      const func = createFunction("x", [createEquation([], lambda)]);
+
+      const visitor = new UsesComposition("x");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True when composition is present inside application", () => {
+      const app = new Application(mockExpr, createComp());
+      const func = createFunction("x", [createEquation([], app)]);
+
+      const visitor = new UsesComposition("x");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True when composition is present within if", () => {
+      const ifExpr = new If(new BooleanPrimitive(true), createComp(), mockExpr);
+      const func = createFunction("f", [createEquation([], ifExpr)]);
+
+      const visitor = new UsesComposition("f");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is False when composition is not present", () => {
+      const func = createFunction("x", [createEquation([], mockExpr)]);
+      const visitor = new UsesComposition("x");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesPatternMatching", () => {
+    it("is True when Pattern Matching with Literal", () => {
+      const pattern = new LiteralPattern(new NumberPrimitive(0));
+      const func = createFunction("factorial", [
+        createEquation([pattern], mockExpr),
+      ]);
+
+      const visitor = new UsesPatternMatching("factorial");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True when Pattern Matching on List", () => {
+      const pattern = new ListPattern([]);
+      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
+
+      const visitor = new UsesPatternMatching("foo");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True when Pattern Matching on anonymous variable (Wildcard)", () => {
+      const pattern = new WildcardPattern();
+      const func = createFunction("baz", [createEquation([pattern], mockExpr)]);
+
+      const visitor = new UsesPatternMatching("baz");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is False when no patterns (or ignored patterns) are used", () => {
+      const func = createFunction("foo", [createEquation([], mockExpr)]);
+      const visitor = new UsesPatternMatching("foo");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesLambda", () => {
+    it("detects lambda when is present", () => {
+      const lambda = new Lambda([], mockExpr);
+      const func = createFunction("f", [createEquation([], lambda)]);
+
+      const visitor = new UsesLambda("f");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("detects lambda when is not present", () => {
+      const func = createFunction("f", [createEquation([], mockExpr)]);
+      const visitor = new UsesLambda("f");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesAnonymousVariable", () => {
+    it("is True if _ is present in parameters", () => {
+      const pattern = new WildcardPattern();
+      const func = createFunction("foo", [createEquation([pattern], mockExpr)]);
+
+      const visitor = new UsesAnonymousVariable("foo");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is True if _ is present in nested structures (e.g. ListPattern)", () => {
+      const innerWildcard = new WildcardPattern();
+
+      const listPattern = new ListPattern([innerWildcard]);
+
+      const func = createFunction("foo", [
+        createEquation([listPattern], mockExpr),
+      ]);
+
+      const visitor = new UsesAnonymousVariable("foo");
+
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is False if _ is not present", () => {
+      const func = createFunction("foo", [createEquation([], mockExpr)]);
+      const visitor = new UsesAnonymousVariable("foo");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesComprehension", () => {
+    it("is True when list comprehension exists", () => {
+      const comp = new ListComprehension(mockExpr, []);
+      const func = createFunction("x", [createEquation([], comp)]);
+
+      const visitor = new UsesComprehension(undefined);
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+
+    it("is False when comprehension doesnt exists", () => {
+      const func = createFunction("x", [createEquation([], mockExpr)]);
+      const visitor = new UsesComprehension("x");
+      expect(executeVisitor(func, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesYield", () => {
+    it("is True when yield exists", () => {
+      const yieldNode = new Yield(mockExpr);
+      const func = createFunction("gen", [createEquation([], yieldNode)]);
+
+      const visitor = new UsesYield("gen");
+      expect(executeVisitor(func, visitor)).to.eq(true);
+    });
+  });
+});

package/tests/analyzer/generic.spec.ts

@@ -0,0 +1,100 @@
+import { expect } from "chai";
+import {
+  TypesParameterAs,
+  TypesReturnAs,
+} from "../../src/analyzer/inspections/generic.js";
+import {
+  TypeSignature,
+  ParameterizedType,
+  SymbolPrimitive,
+  SimpleType,
+} from "yukigo-ast";
+import { executeVisitor } from "../../src/analyzer/utils.js";
+
+describe("Generic Inspections Type Checks", () => {
+  const createTypeSignature = (name: string, params: string[], ret: string) => {
+    const identifier = new SymbolPrimitive(name);
+    const inputTypes = params.map((p) => {
+      const t = new SimpleType(p, []);
+      t.toString = () => p;
+      return t;
+    });
+
+    const returnType = new SimpleType(ret, []);
+    returnType.toString = () => ret;
+
+    const body = new ParameterizedType(inputTypes, returnType, []);
+    return new TypeSignature(identifier, body);
+  };
+
+  describe("TypesParameterAs", () => {
+    it("should find a match when parameter type matches at correct index", () => {
+      // f :: Int -> String -> Bool
+      const node = createTypeSignature("f", ["Int", "String"], "Bool");
+      const visitor = new TypesParameterAs("f", 0, "Int");
+
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should find a match at a specific index (2nd parameter)", () => {
+      // f :: Int -> String -> Bool
+      const node = createTypeSignature("f", ["Int", "String"], "Bool");
+      const visitor = new TypesParameterAs("f", 1, "String");
+
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should NOT throw if parameter index is out of bounds", () => {
+      const node = createTypeSignature("f", ["Int"], "Bool");
+      const visitor = new TypesParameterAs("f", 2, "Int");
+
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+
+    it("should NOT throw if type does not match", () => {
+      const node = createTypeSignature("f", ["Int"], "Bool");
+      const visitor = new TypesParameterAs("f", 1, "String");
+
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+
+    it("should NOT throw if binding name does not match", () => {
+      const node = createTypeSignature("g", ["Int"], "Bool");
+      const visitor = new TypesParameterAs("f", 1, "Int");
+
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+  });
+
+  describe("TypesReturnAs", () => {
+    it("should find a match when return type matches", () => {
+      // f :: Int -> Bool
+      const node = createTypeSignature("f", ["Int"], "Bool");
+      const visitor = new TypesReturnAs("f", "Bool");
+
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should handle complex return types", () => {
+      // f :: Int -> (Int, Int)
+      const node = createTypeSignature("f", ["Int"], "(Int, Int)");
+      const visitor = new TypesReturnAs("f", "(Int, Int)");
+
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should NOT throw if return type does not match", () => {
+      const node = createTypeSignature("f", ["Int"], "Bool");
+      const visitor = new TypesReturnAs("f", "Int");
+
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+
+    it("should NOT throw if binding name does not match", () => {
+      const node = createTypeSignature("g", ["Int"], "Bool");
+      const visitor = new TypesReturnAs("f", "Bool");
+
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+  });
+});

package/tests/analyzer/helpers.spec.ts

@@ -0,0 +1,83 @@
+import { MulangAdapter } from "../../src/index.js";
+import { isYukigoPrimitive, NumberPrimitive, Otherwise } from "yukigo-ast";
+import { assert } from "chai";
+
+describe("Helpers Spec", () => {
+  it("translates correctly mulang's expectations", () => {
+    const mulangAdapter = new MulangAdapter();
+    const mulangExpectations = `
+expectations:
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: squareList
+    inspection: HasBinding
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: squareList
+    inspection: HasLambdaExpression
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: square
+    inspection: HasArithmetic
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: doble
+    inspection: Not:HasBinding
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: square
+    inspection: Uses:x
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: squareList
+    inspection: Uses:map
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: squareList
+    inspection: Not:Uses:map`;
+
+    const yukigoExpectations =
+      mulangAdapter.translateMulangExpectations(mulangExpectations);
+    assert.deepEqual(yukigoExpectations, [
+      {
+        inspection: "HasBinding",
+        binding: "squareList",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasLambdaExpression",
+        binding: "squareList",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasArithmetic",
+        binding: "square",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasBinding",
+        binding: "doble",
+        args: [],
+        expected: false,
+      },
+      {
+        inspection: "Uses",
+        binding: "square",
+        args: ["x"],
+        expected: true,
+      },
+      {
+        inspection: "Uses",
+        binding: "squareList",
+        args: ["map"],
+        expected: true,
+      },
+      {
+        inspection: "Uses",
+        binding: "squareList",
+        args: ["map"],
+        expected: false,
+      },
+    ]);
+  });
+  it("detects correctly YukigoPrimitive", () => {
+    assert.isFalse(isYukigoPrimitive(new Otherwise()));
+    assert.isTrue(isYukigoPrimitive(new NumberPrimitive(4)));
+  });
+});