yukigo 0.2.3 → 0.3.2

package/tests/analyzer/generic.spec.ts

@@ -1,178 +1,178 @@
-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;
-    });
-  });
-});
+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,89 +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: HasLambda
-  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-    binding: square
-    inspection: UsesArithmetic
-  - !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: "Declares",
-        binding: "*",
-        args: ["squareList"],
-        expected: true,
-        targetSuffix: "named",
-      },
-      {
-        inspection: "UsesLambda",
-        binding: "squareList",
-        args: [],
-        expected: true,
-      },
-      {
-        inspection: "UsesArithmetic",
-        binding: "square",
-        args: [],
-        expected: true,
-      },
-      {
-        inspection: "Declares",
-        binding: "*",
-        args: ["doble"],
-        expected: false,
-        targetSuffix: "named",
-      },
-      {
-        inspection: "Uses",
-        binding: "square",
-        args: ["x"],
-        expected: true,
-        targetSuffix: "named",
-      },
-      {
-        inspection: "Uses",
-        binding: "squareList",
-        args: ["map"],
-        expected: true,
-        targetSuffix: "named",
-      },
-      {
-        inspection: "Uses",
-        binding: "squareList",
-        args: ["map"],
-        expected: false,
-        targetSuffix: "named",
-      },
-    ]);
-  });
-  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: "Declares",
+        binding: "squareList",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasLambdaExpression",
+        binding: "squareList",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasArithmetic",
+        binding: "square",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "Declares",
+        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)));
+  });
+});