yukigo 0.2.0 → 0.2.3

package/src/utils/helpers.ts

@@ -1,11 +1,32 @@
 import { parseDocument } from "yaml";
-import { InspectionRule } from "../analyzer/index.js";
+import {
+  InspectionRule,
+  TargetSuffix,
+} from "../analyzer/index.js";
+
+const declareMap: Record<string, string> = {
+  HasBinding: "Declares",
+  HasTypeDeclaration: "DeclaresTypeAlias",
+  HasTypeSignature: "DeclaresTypeSignature",
+  HasVariable: "DeclaresVariable",
+};
+const V0_HAS_INSPECTIONS = new Set([
+  "HasBinding", "HasTypeDeclaration", "HasTypeSignature", "HasVariable",
+  "HasArity", "HasDirectRecursion", "HasComposition", "HasComprehension",
+  "HasForeach", "HasIf", "HasGuards", "HasConditional", "HasLambda",
+  "HasRepeat", "HasWhile", "HasUsage", "HasAnonymousVariable",
+  "HasNot", "HasForall", "HasFindall",
+]);
 
 type MulangInspection = {
   inspection: string;
   binding: string;
+  args?: string[];
 };
 
+const NEGATION_PREFIXES = new Set(["Not", "Except"]);
+const SUFFIX_ARGS = new Set<TargetSuffix>(["like", "except"]);
+
 const isValidFormat = (inspection: any): inspection is MulangInspection =>
   typeof inspection === "object" &&
   "inspection" in inspection &&
@@ -17,22 +38,27 @@ const isValidFormat = (inspection: any): inspection is MulangInspection =>
  * @returns An array of InspectionRule objects.
  */
 export class MulangAdapter {
-  public translateMulangInspection(mulangInspection: any): InspectionRule {
+  public translateMulangInspection(mulangInspection: unknown): InspectionRule {
     if (!isValidFormat(mulangInspection))
       throw new Error(
-        `Skipping malformed Mulang inspection entry: ${mulangInspection}`
+        `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);
+    // transforms Mulang v0 to v2
+    const { inspection, expected, binding, args } =
+      this.transformToV2(mulangInspection);
+
+    const { resolvedArgs, targetSuffix, matcher } =
+      this.retrieveArguments(args);
 
     return {
-      inspection: expected ? inspection[0] : inspection[1],
+      inspection,
       expected,
-      args,
-      binding: mulangInspection.binding,
+      binding,
+      args: resolvedArgs,
+      // these should not exist in the InspectionRule if they are undefined
+      ...(targetSuffix !== undefined && { targetSuffix }),
+      ...(matcher !== undefined && { matcher }),
     };
   }
 
@@ -64,4 +90,80 @@ export class MulangAdapter {
 
     return inspectionRules;
   }
+
+  private transformToV2(mulangInspection: MulangInspection) {
+    const parts = mulangInspection.inspection.split(":");
+    const {
+      expected,
+      inspection,
+      args: parsedArgs,
+    } = this.parseNegation(parts);
+    const args = mulangInspection.args ?? parsedArgs;
+    const v2 = this.applyV0ToV2(inspection, args, mulangInspection.binding);
+    return { expected, ...v2 };
+  }
+  private parseNegation(parts: string[]) {
+    const negated = NEGATION_PREFIXES.has(parts[0]);
+    return {
+      expected: !negated,
+      inspection: parts[negated ? 1 : 0],
+      args: parts.slice(negated ? 2 : 1),
+    };
+  }
+  private applyV0ToV2(inspection: string, args: string[], binding: string) {
+    if (inspection in declareMap)
+      return {
+        inspection: declareMap[inspection],
+        ...promoteBindingToTarget(args, binding),
+      };
+
+    if (inspection === "HasArity")
+      return {
+        inspection: "DeclaresComputationWithArity",
+        args: [args[0], ...(binding && binding !== "*" ? [binding] : [])],
+        binding: "*",
+      };
+
+    if (V0_HAS_INSPECTIONS.has(inspection))
+      return { inspection: inspection === "HasUsage" ? "Uses" : inspection.replace(/^Has/, "Uses"), args, binding };
+
+    return { inspection, args, binding };
+  }
+
+  private retrieveArguments(args: string[]) {
+    const targetSuffix = args.find((a): a is TargetSuffix =>
+      SUFFIX_ARGS.has(a as TargetSuffix),
+    );
+
+    const matcherIndex = args.findIndex((a) => a.startsWith("With"));
+    const matcher =
+      matcherIndex !== -1
+        ? {
+            type: "with_" + args[matcherIndex].slice(4).toLowerCase(),
+            value: args[matcherIndex + 1],
+          }
+        : undefined;
+
+    const consumed = new Set([
+      ...(targetSuffix ? [targetSuffix] : []),
+      ...(matcherIndex !== -1
+        ? [args[matcherIndex], args[matcherIndex + 1]]
+        : []),
+    ]);
+
+    const resolvedArgs = args.filter((a) => !consumed.has(a));
+
+    return {
+      targetSuffix:
+        targetSuffix ??
+        (resolvedArgs.length > 0 ? ("named" as TargetSuffix) : undefined),
+      matcher,
+      resolvedArgs,
+    };
+  }
 }
+
+const promoteBindingToTarget = (args: string[], binding: string) => ({
+  args: binding && binding !== "*" ? [binding, ...args] : args,
+  binding: "*",
+});

package/tests/analyzer/helpers.spec.ts

@@ -12,10 +12,10 @@ expectations:
     inspection: HasBinding
   - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
     binding: squareList
-    inspection: HasLambdaExpression
+    inspection: HasLambda
   - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
     binding: square
-    inspection: HasArithmetic
+    inspection: UsesArithmetic
   - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
     binding: doble
     inspection: Not:HasBinding
@@ -31,48 +31,54 @@ expectations:
 
     const yukigoExpectations =
       mulangAdapter.translateMulangExpectations(mulangExpectations);
+
     assert.deepEqual(yukigoExpectations, [
       {
-        inspection: "HasBinding",
-        binding: "squareList",
-        args: [],
+        inspection: "Declares",
+        binding: "*",
+        args: ["squareList"],
         expected: true,
+        targetSuffix: "named",
       },
       {
-        inspection: "HasLambdaExpression",
+        inspection: "UsesLambda",
         binding: "squareList",
         args: [],
         expected: true,
       },
       {
-        inspection: "HasArithmetic",
+        inspection: "UsesArithmetic",
         binding: "square",
         args: [],
         expected: true,
       },
       {
-        inspection: "HasBinding",
-        binding: "doble",
-        args: [],
+        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",
       },
     ]);
   });

package/tests/tester/Tester.spec.ts

@@ -12,7 +12,6 @@ import {
   SymbolPrimitive,
   ArithmeticBinaryOperation,
   Lambda,
-  Call,
   Application,
   VariablePattern,
 } from "yukigo-ast";