yukigo 0.2.2 → 0.3.1

package/dist/utils/helpers.js

@@ -1,13 +1,4 @@
 import { parseDocument } from "yaml";
-const declareMap = {
-    HasBinding: "Declares",
-    HasTypeDeclaration: "DeclaresTypeAlias",
-    HasTypeSignature: "DeclaresTypeSignature",
-    HasVariable: "DeclaresVariable",
-    HasDirectRecursion: "DeclaresRecursively",
-};
-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;
@@ -20,17 +11,14 @@ 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);
         return {
-            inspection,
+            inspection: expected ? inspection[0] : inspection[1],
             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) {
@@ -56,65 +44,4 @@ export class MulangAdapter {
         }
         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[0]}`,
-                ...promoteBindingToTarget([], binding),
-            };
-        if (inspection.startsWith("Has"))
-            return {
-                inspection: inspection.replace(/^Has(Usage)?/, (_, usage) => usage ? "Uses" : "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.2.2",
+  "version": "0.3.1",
   "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 {}
+}