yukigo 0.1.0 → 0.2.0

package/tests/analyzer/generic.spec.ts

@@ -1,100 +1,178 @@
-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);
-    });
-  });
-});
+import { expect } from "chai";
+import { Analyzer, InspectionRule } from "../../src/analyzer/index.js";
+import {
+  TypeSignature,
+  ParameterizedType,
+  SymbolPrimitive,
+  SimpleType,
+  Function,
+} from "yukigo-ast";
+
+describe("Generic Inspections", () => {
+  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);
+  };
+
+  it("should allow expectations without args", () => {
+    const ast = [new Function(new SymbolPrimitive("func"), [])];
+    const rules: InspectionRule[] = [
+      {
+        binding: "func",
+        inspection: "HasBinding",
+        expected: true
+      },
+    ];
+    const analyzer = new Analyzer();
+    const results = analyzer.analyze(ast, rules);
+    expect(results[0].passed).to.be.true;
+  });
+  describe("TypesParameterAs", () => {
+    it("should find a match when parameter type matches at correct index", () => {
+      const ast = [createTypeSignature("f", ["Int", "String"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesParameterAs",
+          binding: "f",
+          args: ["0", "Int"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.true;
+    });
+
+    it("should find a match at a specific index (2nd parameter)", () => {
+      const ast = [createTypeSignature("f", ["Int", "String"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesParameterAs",
+          binding: "f",
+          args: ["1", "String"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.true;
+    });
+
+    it("should NOT pass if parameter index is out of bounds", () => {
+      const ast = [createTypeSignature("f", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesParameterAs",
+          binding: "f",
+          args: ["2", "Int"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.false;
+    });
+
+    it("should NOT pass if type does not match", () => {
+      const ast = [createTypeSignature("f", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesParameterAs",
+          binding: "f",
+          args: ["0", "String"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.false;
+    });
+
+    it("should NOT pass if binding name does not match", () => {
+      const ast = [createTypeSignature("g", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesParameterAs",
+          binding: "f",
+          args: ["0", "Int"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.false;
+    });
+  });
+
+  describe("TypesReturnAs", () => {
+    it("should find a match when return type matches", () => {
+      const ast = [createTypeSignature("f", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesReturnAs",
+          binding: "f",
+          args: ["Bool"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.true;
+    });
+
+    it("should handle complex return types", () => {
+      const ast = [createTypeSignature("f", ["Int"], "(Int, Int)")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesReturnAs",
+          binding: "f",
+          args: ["(Int, Int)"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.true;
+    });
+
+    it("should NOT pass if return type does not match", () => {
+      const ast = [createTypeSignature("f", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesReturnAs",
+          binding: "f",
+          args: ["Int"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.false;
+    });
+
+    it("should NOT pass if binding name does not match", () => {
+      const ast = [createTypeSignature("g", ["Int"], "Bool")];
+      const rules: InspectionRule[] = [
+        {
+          inspection: "TypesReturnAs",
+          binding: "f",
+          args: ["Bool"],
+          expected: true,
+        },
+      ];
+      const analyzer = new Analyzer();
+      const results = analyzer.analyze(ast, rules);
+      expect(results[0].passed).to.be.false;
+    });
+  });
+});

package/tests/analyzer/helpers.spec.ts

@@ -1,83 +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)));
-  });
-});
+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)));
+  });
+});