yukigo 0.3.2 → 0.3.6

package/CHANGELOG.md

@@ -1,68 +1,110 @@
-## 0.3.2 (2026-08-04)
+## 0.3.6 (2026-09-13)
 
-### 🩹 Fixes
+### 🧱 Updated Dependencies
 
-- **yukigo:** fix v0 Mulang Inspections translation ([2995ccc](https://github.com/miyukiproject/yukigo/commit/2995ccc))
+- Updated yukigo-ast to 0.3.6
+
+## 0.3.5 (2026-09-13)
 
 ### 🧱 Updated Dependencies
 
-- Updated yukigo-ast to 0.3.2
+- Updated yukigo-ast to 0.3.5
 
-### ❤️ Thank You
+## 0.3.4 (2026-08-05)
 
-- noiseArch
+### 🩹 Fixes
 
-## 0.3.1 (2026-08-01)
+- **yukigo:** Fix MulangAdapter target suffix and matcher ([4d0a988](https://github.com/miyukiproject/yukigo/commit/4d0a988))
+- **yukigo:** fix v0 Mulang Inspections translation ([2995ccc](https://github.com/miyukiproject/yukigo/commit/2995ccc))
 
 ### 🧱 Updated Dependencies
 
-- Updated yukigo-ast to 0.3.1
+- Updated yukigo-ast to 0.3.4
 
-## 0.3.0 (2026-08-01)
+### ❤️ Thank You
 
-### 🚀 Features
+- noiseArch
 
-- Interpreter NativeBody support & YukigoHooks ([0b854b4](https://github.com/miyukiproject/yukigo/commit/0b854b4))
-- **interpreter:** implement semantic error handling and stack traces ([b61768f](https://github.com/miyukiproject/yukigo/commit/b61768f))
-- **interpreter:** integrate Kernel as the primary execution engine ([503af3d](https://github.com/miyukiproject/yukigo/commit/503af3d))
-- **interpreter:** introduce YukigoKernel and command-based infrastructure ([9380892](https://github.com/miyukiproject/yukigo/commit/9380892))
-- **yukigo:** implement and test YukigoKernel ([3d42ac4](https://github.com/miyukiproject/yukigo/commit/3d42ac4))
+## 0.3.3 (2026-08-05)
 
 ### 🩹 Fixes
 
-- **yukigo-e2e:** fixes to pass E2E tests ([02d895f](https://github.com/miyukiproject/yukigo/commit/02d895f))
-- **yukigo:** allow concatenation with Plus operator ([7799416](https://github.com/miyukiproject/yukigo/commit/7799416))
-- **yukigo:** fix circular dependency ([64534a8](https://github.com/miyukiproject/yukigo/commit/64534a8))
-- **yukigo:** failed test didnt throw bc now it handles 1 + "a" ([23ebeb6](https://github.com/miyukiproject/yukigo/commit/23ebeb6))
-- **yukigo:** zero-arity functions and Wollok bugs ([995dad4](https://github.com/miyukiproject/yukigo/commit/995dad4))
-- **yukigo:** ObjectRuntime error should return RaiseCommand not FailCommand ([ccb31fa](https://github.com/miyukiproject/yukigo/commit/ccb31fa))
-- **yukigo:** method registration with arity to allow overload ([8ffcb36](https://github.com/miyukiproject/yukigo/commit/8ffcb36))
-- TypeSignature is not a Binding ([13c2c5a](https://github.com/miyukiproject/yukigo/commit/13c2c5a))
-- **yukigo:** support If and Call nodes in LogicEngine ([a0f4086](https://github.com/miyukiproject/yukigo/commit/a0f4086))
-- **yukigo:** fixed functional tester was evaluating logic tests ([914310e](https://github.com/miyukiproject/yukigo/commit/914310e))
-- **yukigo:** solved scope leak at logical binary operations ([8779899](https://github.com/miyukiproject/yukigo/commit/8779899))
-- ToString operator ([f5284ab](https://github.com/miyukiproject/yukigo/commit/f5284ab))
-- **yukigo:** fix pattern matching in FunctionRuntime ([467cdf7](https://github.com/miyukiproject/yukigo/commit/467cdf7))
-- **yukigo:** fix bitwise negation ([b13ef4d](https://github.com/miyukiproject/yukigo/commit/b13ef4d))
-- **yukigo:** fix asynchronous logic unification and parameter resolution ([e467068](https://github.com/miyukiproject/yukigo/commit/e467068))
-- **yukigo:** arreglo operaciones y sustitucion logica ([c95f33f](https://github.com/miyukiproject/yukigo/commit/c95f33f))
-- fix parsers grammar compilation to export to .cjs ([ef59727](https://github.com/miyukiproject/yukigo/commit/ef59727))
-- **yukigo:** fix tests to reflect correct representations ([76b1512](https://github.com/miyukiproject/yukigo/commit/76b1512))
-- **yukigo:** fix Visitor and LazyRuntime to use new correct methods from context ([0eb9168](https://github.com/miyukiproject/yukigo/commit/0eb9168))
-- **yukigo:** arreglos en logicengine ([0604555](https://github.com/miyukiproject/yukigo/commit/0604555))
-- **yukigo:** fix mini error in oop test ([b9fd07e](https://github.com/miyukiproject/yukigo/commit/b9fd07e))
-- **yukigo:** removed unwanted error handling ([0d1ff15](https://github.com/miyukiproject/yukigo/commit/0d1ff15))
-- **yukigo:** replace instanceof with .is method in analyzer ([d953413](https://github.com/miyukiproject/yukigo/commit/d953413))
-- **yukigo:** add InterpreterConfig as export ([280146c](https://github.com/miyukiproject/yukigo/commit/280146c))
+- **yukigo:** Fix MulangAdapter target suffix and matcher ([4d0a988](https://github.com/miyukiproject/yukigo/commit/4d0a988))
+- **yukigo:** fix v0 Mulang Inspections translation ([2995ccc](https://github.com/miyukiproject/yukigo/commit/2995ccc))
 
 ### 🧱 Updated Dependencies
 
-- Updated yukigo-ast to 0.3.0
+- Updated yukigo-ast to 0.3.3
 
 ### ❤️ Thank You
 
 - noiseArch
 
+## 0.3.2 (2026-08-05)
+
+### 🩹 Fixes
+
+- **yukigo:** fix v0 Mulang Inspections translation ([2995ccc](https://github.com/miyukiproject/yukigo/commit/2995ccc))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.3.2
+
+### ❤️ Thank You
+
+- noiseArch
+
+## 0.3.1 (2026-08-01)
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.3.1
+
+## 0.3.0 (2026-08-01)
+
+### 🚀 Features
+
+- Interpreter NativeBody support & YukigoHooks ([0b854b4](https://github.com/miyukiproject/yukigo/commit/0b854b4))
+- **interpreter:** implement semantic error handling and stack traces ([b61768f](https://github.com/miyukiproject/yukigo/commit/b61768f))
+- **interpreter:** integrate Kernel as the primary execution engine ([503af3d](https://github.com/miyukiproject/yukigo/commit/503af3d))
+- **interpreter:** introduce YukigoKernel and command-based infrastructure ([9380892](https://github.com/miyukiproject/yukigo/commit/9380892))
+- **yukigo:** implement and test YukigoKernel ([3d42ac4](https://github.com/miyukiproject/yukigo/commit/3d42ac4))
+
+### 🩹 Fixes
+
+- **yukigo-e2e:** fixes to pass E2E tests ([02d895f](https://github.com/miyukiproject/yukigo/commit/02d895f))
+- **yukigo:** allow concatenation with Plus operator ([7799416](https://github.com/miyukiproject/yukigo/commit/7799416))
+- **yukigo:** fix circular dependency ([64534a8](https://github.com/miyukiproject/yukigo/commit/64534a8))
+- **yukigo:** failed test didnt throw bc now it handles 1 + "a" ([23ebeb6](https://github.com/miyukiproject/yukigo/commit/23ebeb6))
+- **yukigo:** zero-arity functions and Wollok bugs ([995dad4](https://github.com/miyukiproject/yukigo/commit/995dad4))
+- **yukigo:** ObjectRuntime error should return RaiseCommand not FailCommand ([ccb31fa](https://github.com/miyukiproject/yukigo/commit/ccb31fa))
+- **yukigo:** method registration with arity to allow overload ([8ffcb36](https://github.com/miyukiproject/yukigo/commit/8ffcb36))
+- TypeSignature is not a Binding ([13c2c5a](https://github.com/miyukiproject/yukigo/commit/13c2c5a))
+- **yukigo:** support If and Call nodes in LogicEngine ([a0f4086](https://github.com/miyukiproject/yukigo/commit/a0f4086))
+- **yukigo:** fixed functional tester was evaluating logic tests ([914310e](https://github.com/miyukiproject/yukigo/commit/914310e))
+- **yukigo:** solved scope leak at logical binary operations ([8779899](https://github.com/miyukiproject/yukigo/commit/8779899))
+- ToString operator ([f5284ab](https://github.com/miyukiproject/yukigo/commit/f5284ab))
+- **yukigo:** fix pattern matching in FunctionRuntime ([467cdf7](https://github.com/miyukiproject/yukigo/commit/467cdf7))
+- **yukigo:** fix bitwise negation ([b13ef4d](https://github.com/miyukiproject/yukigo/commit/b13ef4d))
+- **yukigo:** fix asynchronous logic unification and parameter resolution ([e467068](https://github.com/miyukiproject/yukigo/commit/e467068))
+- **yukigo:** arreglo operaciones y sustitucion logica ([c95f33f](https://github.com/miyukiproject/yukigo/commit/c95f33f))
+- fix parsers grammar compilation to export to .cjs ([ef59727](https://github.com/miyukiproject/yukigo/commit/ef59727))
+- **yukigo:** fix tests to reflect correct representations ([76b1512](https://github.com/miyukiproject/yukigo/commit/76b1512))
+- **yukigo:** fix Visitor and LazyRuntime to use new correct methods from context ([0eb9168](https://github.com/miyukiproject/yukigo/commit/0eb9168))
+- **yukigo:** arreglos en logicengine ([0604555](https://github.com/miyukiproject/yukigo/commit/0604555))
+- **yukigo:** fix mini error in oop test ([b9fd07e](https://github.com/miyukiproject/yukigo/commit/b9fd07e))
+- **yukigo:** removed unwanted error handling ([0d1ff15](https://github.com/miyukiproject/yukigo/commit/0d1ff15))
+- **yukigo:** replace instanceof with .is method in analyzer ([d953413](https://github.com/miyukiproject/yukigo/commit/d953413))
+- **yukigo:** add InterpreterConfig as export ([280146c](https://github.com/miyukiproject/yukigo/commit/280146c))
+
+### 🧱 Updated Dependencies
+
+- Updated yukigo-ast to 0.3.0
+
+### ❤️ Thank You
+
+- noiseArch
+
 ## 0.2.3 (2026-05-02)
 
 ### 🩹 Fixes

package/dist/analyzer/index.d.ts

@@ -6,11 +6,18 @@ export type AnalysisResult = {
     actual: boolean;
     error?: string;
 };
+export type TargetSuffix = "named" | "like" | "except";
+export type InspectionMatcher = {
+    type: string;
+    value?: string;
+};
 export type InspectionRule = {
     inspection: string;
     binding?: string;
     args?: string[];
     expected: boolean;
+    targetSuffix?: TargetSuffix;
+    matcher?: InspectionMatcher;
 };
 export declare const DefaultInspectionSet: InspectionMap;
 export declare const DefaultSmellsSet: InspectionMap;

package/dist/utils/helpers.d.ts

@@ -16,7 +16,10 @@ export interface InterpreterConfig {
  * @returns An array of InspectionRule objects.
  */
 export declare class MulangAdapter {
-    translateMulangInspection(mulangInspection: any): InspectionRule;
+    translateMulangInspection(mulangInspection: unknown): InspectionRule;
     translateMulangExpectations(mulangYamlString: string): InspectionRule[];
-    private translateV0Inspection;
+    private transformToV2;
+    private parseNegation;
+    private applyV0ToV2;
+    private retrieveArguments;
 }

package/dist/utils/helpers.js

@@ -1,28 +1,19 @@
 import { parseDocument } from "yaml";
-const V0_INSPECTIONS_Has = [
-    "HasComposition",
-    "HasComprehension",
-    "HasForeach",
-    "HasIf",
-    "HasGuards",
-    "HasConditional",
-    "HasLambda",
-    "HasRepeat",
-    "HasWhile",
-    "HasAnonymousVariable",
-    "HasNot",
-    "HasForall",
-    "HasFindall",
-];
-const V0_INSPECTIONS_Declares = new Map([
-    ["HasBinding", "Declares"],
-    ["HasTypeDeclaration", "DeclaresTypeAlias"],
-    ["HasTypeSignature", "DeclaresTypeSignature"],
-    ["HasVariable", "DeclaresVariable"],
-    ["HasArity", "DeclaresComputationWithArity"],
-    ["HasDirectRecursion", "DeclaresRecursively"],
-    ["HasUsage", "Uses"],
+const declareMap = {
+    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",
 ]);
+const NEGATION_PREFIXES = new Set(["Not", "Except"]);
+const SUFFIX_ARGS = new Set(["like", "except"]);
 const isValidFormat = (inspection) => typeof inspection === "object" &&
     "inspection" in inspection &&
     "binding" in inspection;
@@ -35,16 +26,17 @@ export class MulangAdapter {
     translateMulangInspection(mulangInspection) {
         if (!isValidFormat(mulangInspection))
             throw new Error(`Skipping malformed Mulang inspection entry: ${mulangInspection}`);
-        const inspection = mulangInspection.inspection.split(":");
-        const expected = inspection[0] !== "Not" && inspection[0] !== "Except";
-        const args = inspection.slice(expected ? 1 : 2);
-        const inspectionV0 = expected ? inspection[0] : inspection[1];
-        const inspectionV2 = this.translateV0Inspection(inspectionV0);
+        // transforms Mulang v0 to v2
+        const { inspection, expected, binding, args } = this.transformToV2(mulangInspection);
+        const { resolvedArgs, targetSuffix, matcher } = this.retrieveArguments(args);
         return {
-            inspection: inspectionV2,
+            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 }),
         };
     }
     translateMulangExpectations(mulangYamlString) {
@@ -63,14 +55,69 @@ export class MulangAdapter {
         else {
             throw new Error("Invalid Mulang YAML structure. Expected 'expectations' to be an array.");
         }
-        const inspectionRules = expectations.map((insp) => this.translateMulangInspection(insp));
+        const inspectionRules = [];
+        for (const mulangInspection of expectations) {
+            const inspection = this.translateMulangInspection(mulangInspection);
+            inspectionRules.push(inspection);
+        }
         return inspectionRules;
     }
-    translateV0Inspection(inspection) {
-        if (V0_INSPECTIONS_Declares.has(inspection))
-            return V0_INSPECTIONS_Declares.get(inspection);
-        if (V0_INSPECTIONS_Has.includes(inspection))
-            return inspection.replace("Has", "Uses");
-        return inspection;
+    transformToV2(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 };
+    }
+    parseNegation(parts) {
+        const negated = NEGATION_PREFIXES.has(parts[0]);
+        return {
+            expected: !negated,
+            inspection: parts[negated ? 1 : 0],
+            args: parts.slice(negated ? 2 : 1),
+        };
+    }
+    applyV0ToV2(inspection, args, binding) {
+        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 };
+    }
+    retrieveArguments(args) {
+        const targetSuffix = args.find((a) => SUFFIX_ARGS.has(a));
+        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" : undefined),
+            matcher,
+            resolvedArgs,
+        };
     }
 }
+const promoteBindingToTarget = (args, binding) => ({
+    args: binding && binding !== "*" ? [binding, ...args] : args,
+    binding: "*",
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo",
-  "version": "0.3.2",
+  "version": "0.3.6",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/analyzer/index.ts

@@ -19,11 +19,20 @@ export type AnalysisResult = {
   error?: string;
 };
 
+export type TargetSuffix = "named" | "like" | "except";
+
+export type InspectionMatcher = {
+  type: string;
+  value?: string;
+};
+
 export type InspectionRule = {
   inspection: string;
   binding?: string;
   args?: string[];
   expected: boolean;
+  targetSuffix?: TargetSuffix;
+  matcher?: InspectionMatcher;
 };
 
 export const DefaultInspectionSet: InspectionMap = {

package/src/utils/helpers.ts

@@ -1,113 +1,181 @@
-import { parseDocument } from "yaml";
-import { InspectionRule } from "../analyzer/index.js";
-import { NativeExtension } from "../interpreter/utils.js";
-import { YukigoHook } from "../interpreter/components/hooks/YukigoHook.js";
-
-const V0_INSPECTIONS_Has = [
-  "HasComposition",
-  "HasComprehension",
-  "HasForeach",
-  "HasIf",
-  "HasGuards",
-  "HasConditional",
-  "HasLambda",
-  "HasRepeat",
-  "HasWhile",
-  "HasAnonymousVariable",
-  "HasNot",
-  "HasForall",
-  "HasFindall",
-];
-
-const V0_INSPECTIONS_Declares: Map<string, string> = new Map([
-  ["HasBinding", "Declares"],
-  ["HasTypeDeclaration", "DeclaresTypeAlias"],
-  ["HasTypeSignature", "DeclaresTypeSignature"],
-  ["HasVariable", "DeclaresVariable"],
-  ["HasArity", "DeclaresComputationWithArity"],
-  ["HasDirectRecursion", "DeclaresRecursively"],
-  ["HasUsage", "Uses"],
-]);
-
-type MulangInspection = {
-  inspection: string;
-  binding: string;
-};
-
-export type LogicSearchMode = "first" | "all" | "stream";
-export interface InterpreterConfig {
-  nativeProviders: Map<string, NativeExtension>;
-  lazyLoading: boolean;
-  debug: boolean;
-  outputMode: LogicSearchMode;
-  mutability: boolean;
-  hooks?: YukigoHook[];
-}
-
-const isValidFormat = (inspection: any): inspection is MulangInspection =>
-  typeof inspection === "object" &&
-  "inspection" in inspection &&
-  "binding" in inspection;
-
-/**
- * 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 (!isValidFormat(mulangInspection))
-      throw new Error(
-        `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);
-
-    const inspectionV0 = expected ? inspection[0] : inspection[1];
-    const inspectionV2 = this.translateV0Inspection(inspectionV0);
-    return {
-      inspection: inspectionV2,
-      expected,
-      args,
-      binding: mulangInspection.binding,
-    };
-  }
-
-  public translateMulangExpectations(
-    mulangYamlString: string,
-  ): InspectionRule[] {
-    if (!mulangYamlString) return [];
-    const parsedYaml = parseDocument(mulangYamlString).toJS();
-
-    if (!parsedYaml) return [];
-
-    let expectations: any[] = [];
-    if (Array.isArray(parsedYaml)) {
-      expectations = parsedYaml;
-    } else if (Array.isArray(parsedYaml.expectations)) {
-      expectations = parsedYaml.expectations;
-    } else {
-      throw new Error(
-        "Invalid Mulang YAML structure. Expected 'expectations' to be an array.",
-      );
-    }
-
-    const inspectionRules: InspectionRule[] = expectations.map((insp) =>
-      this.translateMulangInspection(insp),
-    );
-    return inspectionRules;
-  }
-
-  private translateV0Inspection(inspection: string): string {
-    if (V0_INSPECTIONS_Declares.has(inspection))
-      return V0_INSPECTIONS_Declares.get(inspection)!;
-
-    if (V0_INSPECTIONS_Has.includes(inspection))
-      return inspection.replace("Has", "Uses");
-
-    return inspection;
-  }
-}
+import { parseDocument } from "yaml";
+import {
+  InspectionRule,
+  TargetSuffix,
+} from "../analyzer/index.js";
+import { NativeExtension } from "../interpreter/utils.js";
+import { YukigoHook } from "../interpreter/components/hooks/YukigoHook.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[];
+};
+
+export type LogicSearchMode = "first" | "all" | "stream";
+export interface InterpreterConfig {
+  nativeProviders: Map<string, NativeExtension>;
+  lazyLoading: boolean;
+  debug: boolean;
+  outputMode: LogicSearchMode;
+  mutability: boolean;
+  hooks?: YukigoHook[];
+}
+
+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 &&
+  "binding" in inspection;
+
+/**
+ * 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: unknown): InspectionRule {
+    if (!isValidFormat(mulangInspection))
+      throw new Error(
+        `Skipping malformed Mulang inspection entry: ${mulangInspection}`,
+      );
+
+    // transforms Mulang v0 to v2
+    const { inspection, expected, binding, args } =
+      this.transformToV2(mulangInspection);
+
+    const { resolvedArgs, targetSuffix, matcher } =
+      this.retrieveArguments(args);
+
+    return {
+      inspection,
+      expected,
+      binding,
+      args: resolvedArgs,
+      // these should not exist in the InspectionRule if they are undefined
+      ...(targetSuffix !== undefined && { targetSuffix }),
+      ...(matcher !== undefined && { matcher }),
+    };
+  }
+
+  public translateMulangExpectations(
+    mulangYamlString: string
+  ): InspectionRule[] {
+    if (!mulangYamlString) return [];
+    const parsedYaml = parseDocument(mulangYamlString).toJS();
+
+    if (!parsedYaml) return [];
+
+    let expectations: any[] = [];
+    if (Array.isArray(parsedYaml)) {
+      expectations = parsedYaml;
+    } else if (Array.isArray(parsedYaml.expectations)) {
+      expectations = parsedYaml.expectations;
+    } else {
+      throw new Error(
+        "Invalid Mulang YAML structure. Expected 'expectations' to be an array."
+      );
+    }
+
+    const inspectionRules: InspectionRule[] = [];
+
+    for (const mulangInspection of expectations) {
+      const inspection = this.translateMulangInspection(mulangInspection);
+      inspectionRules.push(inspection);
+    }
+
+    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

@@ -1,83 +1,173 @@
-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)));
-  });
-});
+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: "*",
+        args: ["squareList"],
+        expected: true,
+        targetSuffix: "named",
+      },
+      {
+        inspection: "HasLambdaExpression",
+        binding: "squareList",
+        args: [],
+        expected: true,
+      },
+      {
+        inspection: "HasArithmetic",
+        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("translates mulang's expectations with target suffixes and matchers", () => {
+    const mulangAdapter = new MulangAdapter();
+    const expectations = `
+expectations:
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: "*"
+    inspection: Calls:foo:except:WithNumber:4
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: "*"
+    inspection: Calls:bar:like:WithAnything
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: "*"
+    inspection: Calls:baz:WithTrue
+  - !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+    binding: "*"
+    inspection: Calls:WithAnything
+`;
+    const yukigoExpectations = mulangAdapter.translateMulangExpectations(expectations);
+    assert.deepEqual(yukigoExpectations, [
+      {
+        inspection: "Calls",
+        binding: "*",
+        args: ["foo"],
+        expected: true,
+        targetSuffix: "except",
+        matcher: {
+          type: "with_number",
+          value: "4"
+        }
+      },
+      {
+        inspection: "Calls",
+        binding: "*",
+        args: ["bar"],
+        expected: true,
+        targetSuffix: "like",
+        matcher: {
+          type: "with_anything",
+          value: undefined
+        }
+      },
+      {
+        inspection: "Calls",
+        binding: "*",
+        args: ["baz"],
+        expected: true,
+        targetSuffix: "named",
+        matcher: {
+          type: "with_true",
+          value: undefined
+        }
+      },
+      {
+        inspection: "Calls",
+        binding: "*",
+        args: [],
+        expected: true,
+        matcher: {
+          type: "with_anything",
+          value: undefined
+        }
+      }
+    ]);
+  });
+  it("translates correctly expectations that provide arguments in the args property instead of the inspection string", () => {
+    const mulangAdapter = new MulangAdapter();
+    const rules = [
+      {
+        binding: "cantidadRuedasMoto",
+        inspection: "HasUsage",
+        args: ["cantidadRuedasBicicleta"],
+        expected: true
+      }
+    ];
+    const yukigoExpectations = rules.map((r) => mulangAdapter.translateMulangInspection(r));
+    assert.deepEqual(yukigoExpectations, [
+      {
+        inspection: "Uses",
+        binding: "cantidadRuedasMoto",
+        args: ["cantidadRuedasBicicleta"],
+        expected: true,
+        targetSuffix: "named"
+      }
+    ]);
+  });
+  it("detects correctly YukigoPrimitive", () => {
+    assert.isFalse(isYukigoPrimitive(new Otherwise()));
+    assert.isTrue(isYukigoPrimitive(new NumberPrimitive(4)));
+  });
+});