yukigo 0.2.3 → 0.3.2

package/dist/utils/helpers.js

@@ -1,19 +1,28 @@
 import { parseDocument } from "yaml";
-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 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 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;
@@ -26,17 +35,16 @@ export class MulangAdapter {
     translateMulangInspection(mulangInspection) {
         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);
+        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);
         return {
-            inspection,
+            inspection: inspectionV2,
             expected,
-            binding,
-            args: resolvedArgs,
-            // these should not exist in the InspectionRule if they are undefined
-            ...(targetSuffix !== undefined && { targetSuffix }),
-            ...(matcher !== undefined && { matcher }),
+            args,
+            binding: mulangInspection.binding,
         };
     }
     translateMulangExpectations(mulangYamlString) {
@@ -55,69 +63,14 @@ export class MulangAdapter {
         else {
             throw new Error("Invalid Mulang YAML structure. Expected 'expectations' to be an array.");
         }
-        const inspectionRules = [];
-        for (const mulangInspection of expectations) {
-            const inspection = this.translateMulangInspection(mulangInspection);
-            inspectionRules.push(inspection);
-        }
+        const inspectionRules = expectations.map((insp) => this.translateMulangInspection(insp));
         return inspectionRules;
     }
-    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,
-        };
+    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;
     }
 }
-const promoteBindingToTarget = (args, binding) => ({
-    args: binding && binding !== "*" ? [binding, ...args] : args,
-    binding: "*",
-});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yukigo",
-  "version": "0.2.3",
+  "version": "0.3.2",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,20 +13,7 @@
     "test": "mocha --import=tsx"
   },
   "dependencies": {
-    "typescript": "^5.9.2",
-    "yaml": "^2.8.0"
-  },
-  "peerDependencies": {
-    "yukigo-ast": "^0.2.0"
-  },
-  "devDependencies": {
-    "@types/chai": "^5.2.2",
-    "@types/mocha": "^10.0.10",
-    "@types/node": "^24.2.0",
-    "chai": "^6.2.0",
-    "mocha": "^11.7.1",
-    "ts-node": "^10.9.2",
-    "tsx": "^4.21.0",
-    "typescript-eslint": "^8.33.1"
+    "yaml": "^2.8.0",
+    "yukigo-ast": "^0.3.0"
   }
 }

package/src/analyzer/GraphBuilder.ts

@@ -1,142 +1,143 @@
-import {
-  Application,
-  AST,
-  ASTNode,
-  Call,
-  Class,
-  Fact,
-  Function,
-  Interface,
-  Method,
-  New,
-  Object as YuObject,
-  Procedure,
-  Rule,
-  SymbolPrimitive,
-  TraverseVisitor,
-  TypeAlias,
-  TypeSignature,
-  Exist,
-} from "yukigo-ast";
-
-type DefinitionMap = Map<string, ASTNode[]>;
-type CallsMap = Map<string, string[]>;
-
-export type SymbolGraph = {
-  defs: DefinitionMap;
-  calls: CallsMap;
-};
-
-export class GraphBuilder extends TraverseVisitor {
-  private defs: DefinitionMap = new Map();
-  private calls: CallsMap = new Map();
-  private scope: string = "";
-
-  public build(ast: AST): SymbolGraph {
-    ast.forEach((node) => node.accept(this));
-    return { defs: this.defs, calls: this.calls };
-  }
-
-  private addDefinition(name: string, node: ASTNode): void {
-    const existing = this.defs.get(name) || [];
-    this.defs.set(name, [...existing, node]);
-  }
-
-  visitFunction(node: Function): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.traverseCollection(node.equations);
-    this.scope = "";
-  }
-
-  visitMethod(node: Method): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.traverseCollection(node.equations);
-    this.scope = "";
-  }
-
-  visitProcedure(node: Procedure): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.traverseCollection(node.equations);
-    this.scope = "";
-  }
-
-  visitRule(node: Rule): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.traverseCollection(node.equations);
-    this.scope = "";
-  }
-
-  visitFact(node: Fact): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.traverseCollection(node.patterns);
-    this.scope = "";
-  }
-
-  visitClass(node: Class): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    node.expression.accept(this);
-    this.scope = "";
-  }
-
-  visitObject(node: YuObject): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    node.expression.accept(this);
-    this.scope = "";
-  }
-
-  visitInterface(node: Interface): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    node.expression.accept(this);
-    this.scope = "";
-  }
-
-  visitTypeAlias(node: TypeAlias): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.scope = "";
-  }
-
-  visitTypeSignature(node: TypeSignature): void {
-    this.scope = node.identifier.value;
-    this.addDefinition(this.scope, node);
-    this.scope = "";
-  }
-
-  visitCall(node: Call): void {
-    if (!this.scope) return;
-
-    const arr = this.calls.get(this.scope) || [];
-    this.calls.set(this.scope, [node.callee.value, ...arr]);
-  }
-
-  visitApplication(node: Application): void {
-    if (!this.scope) return;
-
-    const arr = this.calls.get(this.scope) || [];
-    if (node.functionExpr instanceof SymbolPrimitive)
-      this.calls.set(this.scope, [node.functionExpr.value, ...arr]);
-    else node.functionExpr.accept(this);
-  }
-
-  visitNew(node: New): void {
-    if (!this.scope) return;
-
-    const arr = this.calls.get(this.scope) || [];
-    this.calls.set(this.scope, [node.identifier.value, ...arr]);
-  }
-
-  visitExist(node: Exist): void {
-    if (!this.scope) return;
-
-    const arr = this.calls.get(this.scope) || [];
-    this.calls.set(this.scope, [node.identifier.value, ...arr]);
-  }
-}
+import {
+  Application,
+  AST,
+  ASTNode,
+  Call,
+  Class,
+  Fact,
+  Function,
+  Interface,
+  Method,
+  New,
+  Object as YuObject,
+  Procedure,
+  Rule,
+  SymbolPrimitive,
+  TraverseVisitor,
+  TypeAlias,
+  TypeSignature,
+  Exist,
+} from "yukigo-ast";
+
+type DefinitionMap = Map<string, ASTNode[]>;
+type CallsMap = Map<string, string[]>;
+
+export type SymbolGraph = {
+  defs: DefinitionMap;
+  calls: CallsMap;
+};
+
+export class GraphBuilder extends TraverseVisitor {
+  private defs: DefinitionMap = new Map();
+  private calls: CallsMap = new Map();
+  private scope: string = "";
+
+  public build(ast: AST): SymbolGraph {
+    ast.forEach((node) => node.accept(this));
+    return { defs: this.defs, calls: this.calls };
+  }
+
+  private addDefinition(name: string, node: ASTNode): void {
+    const existing = this.defs.get(name) || [];
+    this.defs.set(name, [...existing, node]);
+  }
+
+  visitFunction(node: Function): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.traverseCollection(node.equations);
+    this.scope = "";
+  }
+
+  visitMethod(node: Method): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.traverseCollection(node.equations);
+    this.scope = "";
+  }
+
+  visitProcedure(node: Procedure): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.traverseCollection(node.equations);
+    this.scope = "";
+  }
+
+  visitRule(node: Rule): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.traverseCollection(node.equations);
+    this.scope = "";
+  }
+
+  visitFact(node: Fact): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.traverseCollection(node.patterns);
+    this.scope = "";
+  }
+
+  visitClass(node: Class): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    node.expression.accept(this);
+    this.scope = "";
+  }
+
+  visitObject(node: YuObject): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    node.expression.accept(this);
+    this.scope = "";
+  }
+
+  visitInterface(node: Interface): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    node.expression.accept(this);
+    this.scope = "";
+  }
+
+  visitTypeAlias(node: TypeAlias): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.scope = "";
+  }
+
+  visitTypeSignature(node: TypeSignature): void {
+    this.scope = node.identifier.value;
+    this.addDefinition(this.scope, node);
+    this.scope = "";
+  }
+
+  visitCall(node: Call): void {
+    if (!this.scope) return;
+
+    const arr = this.calls.get(this.scope) || [];
+    this.calls.set(this.scope, [node.callee.value, ...arr]);
+  }
+
+  visitApplication(node: Application): void {
+    if (!this.scope) return;
+
+    const arr = this.calls.get(this.scope) || [];
+    if (node.functionExpr.is(SymbolPrimitive))
+      this.calls.set(this.scope, [node.functionExpr.value, ...arr]);
+    else node.functionExpr.accept(this);
+  }
+
+  visitNew(node: New): void {
+    if (!this.scope) return;
+
+    const arr = this.calls.get(this.scope) || [];
+    this.calls.set(this.scope, [node.identifier.value, ...arr]);
+  }
+
+  visitExist(node: Exist): void {
+    if (!this.scope) return;
+
+    const arr = this.calls.get(this.scope) || [];
+    this.calls.set(this.scope, [node.identifier.value, ...arr]);
+  }
+  public fallback(node: ASTNode): void {}
+}