yukigo 0.2.2 → 0.3.1

package/src/analyzer/index.ts

@@ -1,194 +1,185 @@
-import { AST, TraverseVisitor, StopTraversalException } from "yukigo-ast";
-import { genericInspections } from "./inspections/generic/generic.js";
-import { functionalInspections } from "./inspections/functional/functional.js";
-import { logicInspections } from "./inspections/logic/logic.js";
-import { objectInspections } from "./inspections/object/object.js";
-import { imperativeInspections } from "./inspections/imperative/imperative.js";
-import { InspectionMap, VisitorConstructor } from "./utils.js";
-import { functionalSmells } from "./inspections/functional/smells.js";
-import { logicSmells } from "./inspections/logic/smells.js";
-import { objectSmells } from "./inspections/object/smells.js";
-import { imperativeSmells } from "./inspections/imperative/smells.js";
-import { genericSmells } from "./inspections/generic/smells.js";
-import { GraphBuilder } from "./GraphBuilder.js";
-
-export type AnalysisResult = {
-  rule: InspectionRule;
-  passed: boolean;
-  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 const DefaultInspectionSet: InspectionMap = {
-  ...genericInspections,
-  ...functionalInspections,
-  ...logicInspections,
-  ...objectInspections,
-  ...imperativeInspections,
-};
-export const DefaultSmellsSet: InspectionMap = {
-  ...genericSmells,
-  ...functionalSmells,
-  ...logicSmells,
-  ...objectSmells,
-  ...imperativeSmells,
-};
-
-/**
- * The Analyzer class.
- * @remarks
- * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
- */
-export class Analyzer {
-  /**
-   * The set of inspections that are available for the Analyzer.
-   * You can load your set of inspections or leave the default one.
-   * @defaultValue a default set of inspections for each supported paradigm
-   */
-  private inspectionConstructors: InspectionMap = {};
-  private smellsConstructors: InspectionMap = {};
-  constructor(inspectionSet?: InspectionMap, smellsSet?: InspectionMap) {
-    this.inspectionConstructors = inspectionSet ?? DefaultInspectionSet;
-    this.smellsConstructors = smellsSet ?? DefaultSmellsSet;
-  }
-
-  /**
-   * Registers a new custom inspection handler after Analyzer was instantiated.
-   * @param name The name of the inspection (e.g., "HasArithmetic").
-   * @param visitorConstructor The constructor for the TraverseVisitor class.
-   */
-  public registerInspection(
-    name: string,
-    visitorConstructor: VisitorConstructor
-  ) {
-    this.inspectionConstructors[name] = visitorConstructor;
-  }
-
-  /**
-   * Runs a list of inspection rules against the AST.
-   * @param ast The parsed AST.
-   * @param rules The array of inspection rules to run.
-   * @returns An array of analysis results.
-   * @example
-   * const rules: InspectionRule[] = [
-   *  {
-   *    inspection: "HasBinding",
-   *    args: { name: "minimoEntre" },
-   *    expected: false,
-   *  },
-   *  {
-   *    inspection: "HasBinding",
-   *    args: { name: "squareList" },
-   *    expected: true,
-   *  }
-   * ]
-   * const analyzer = new ASTAnalyzer(ast);
-   * const analysisResults = analyzer.analyze(expectations);
-   */
-  public analyze(ast: AST, rules: InspectionRule[]): AnalysisResult[] {
-    const ruleResults: Map<InspectionRule, AnalysisResult> = new Map();
-    const graphBuilder = new GraphBuilder();
-    const { defs, calls } = graphBuilder.build(ast);
-
-    for (const rule of rules) {
-      let inspectionName = rule.inspection;
-      let isTransitive = true;
-
-      if (inspectionName.startsWith("Intransitive:")) {
-        isTransitive = false;
-        inspectionName = inspectionName.replace("Intransitive:", "");
-      }
-
-      const InspectionClass = this.inspectionConstructors[inspectionName];
-      if (!InspectionClass) {
-        ruleResults.set(rule, {
-          rule,
-          passed: false,
-          actual: false,
-          error: "Unknown inspection: " + inspectionName,
-        });
-        continue;
-      }
-
-      if (InspectionClass.IS_INTRANSITIVE) isTransitive = false;
-
-      let targets: { node: any; binding?: string }[] = [];
-
-      // Case 1: Global Inspection (No binding or wildcard)
-      if (!rule.binding || rule.binding === "*") {
-        targets = ast.map((n) => ({ node: n, binding: undefined }));
-      }
-      // Case 2: Directed Inspection (Specific binding)
-      else {
-        const workList = [rule.binding];
-        const visited = new Set<string>();
-
-        while (workList.length > 0) {
-          const currentBinding = workList.shift();
-          if (visited.has(currentBinding)) continue;
-          visited.add(currentBinding);
-
-          const node = defs.get(currentBinding);
-          if (node)
-            node.forEach((n) =>
-              targets.push({ node: n, binding: currentBinding })
-            );
-
-          if (isTransitive) {
-            const deps = calls.get(currentBinding) || [];
-            workList.push(...deps);
-          }
-        }
-      }
-
-      let actual = false;
-      let error: string;
-
-      // Execution Loop
-      const isGlobalVisitor = !rule.binding || rule.binding === "*";
-      const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
-      const args = rule.args ?? []
-      const visitor = new InspectionClass(...args, normalizedBinding);
-
-      for (const { node, binding } of targets) {
-        try {
-          if (!isGlobalVisitor && visitor.setBinding) {
-            visitor.setBinding(binding);
-          }
-          node.accept(visitor);
-        } catch (e) {
-          if (e instanceof StopTraversalException) {
-            actual = true;
-            break; // Short-circuit: Rule passed
-          } else {
-            error = (e as Error).message;
-          }
-        }
-      }
-
-      ruleResults.set(rule, {
-        rule,
-        passed: actual === rule.expected,
-        actual,
-        error,
-      });
-    }
-    return [...ruleResults.values()];
-  }
-}
+import { AST, TraverseVisitor, StopTraversalException } from "yukigo-ast";
+import { genericInspections } from "./inspections/generic/generic.js";
+import { functionalInspections } from "./inspections/functional/functional.js";
+import { logicInspections } from "./inspections/logic/logic.js";
+import { objectInspections } from "./inspections/object/object.js";
+import { imperativeInspections } from "./inspections/imperative/imperative.js";
+import { InspectionMap, VisitorConstructor } from "./utils.js";
+import { functionalSmells } from "./inspections/functional/smells.js";
+import { logicSmells } from "./inspections/logic/smells.js";
+import { objectSmells } from "./inspections/object/smells.js";
+import { imperativeSmells } from "./inspections/imperative/smells.js";
+import { genericSmells } from "./inspections/generic/smells.js";
+import { GraphBuilder } from "./GraphBuilder.js";
+
+export type AnalysisResult = {
+  rule: InspectionRule;
+  passed: boolean;
+  actual: boolean;
+  error?: string;
+};
+
+export type InspectionRule = {
+  inspection: string;
+  binding?: string;
+  args?: string[];
+  expected: boolean;
+};
+
+export const DefaultInspectionSet: InspectionMap = {
+  ...genericInspections,
+  ...functionalInspections,
+  ...logicInspections,
+  ...objectInspections,
+  ...imperativeInspections,
+};
+export const DefaultSmellsSet: InspectionMap = {
+  ...genericSmells,
+  ...functionalSmells,
+  ...logicSmells,
+  ...objectSmells,
+  ...imperativeSmells,
+};
+
+/**
+ * The Analyzer class.
+ * @remarks
+ * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
+ */
+export class Analyzer {
+  /**
+   * The set of inspections that are available for the Analyzer.
+   * You can load your set of inspections or leave the default one.
+   * @defaultValue a default set of inspections for each supported paradigm
+   */
+  private inspectionConstructors: InspectionMap = {};
+  private smellsConstructors: InspectionMap = {};
+  constructor(inspectionSet?: InspectionMap, smellsSet?: InspectionMap) {
+    this.inspectionConstructors = inspectionSet ?? DefaultInspectionSet;
+    this.smellsConstructors = smellsSet ?? DefaultSmellsSet;
+  }
+
+  /**
+   * Registers a new custom inspection handler after Analyzer was instantiated.
+   * @param name The name of the inspection (e.g., "HasArithmetic").
+   * @param visitorConstructor The constructor for the TraverseVisitor class.
+   */
+  public registerInspection(
+    name: string,
+    visitorConstructor: VisitorConstructor,
+  ) {
+    this.inspectionConstructors[name] = visitorConstructor;
+  }
+
+  /**
+   * Runs a list of inspection rules against the AST.
+   * @param ast The parsed AST.
+   * @param rules The array of inspection rules to run.
+   * @returns An array of analysis results.
+   * @example
+   * const rules: InspectionRule[] = [
+   *  {
+   *    inspection: "HasBinding",
+   *    args: { name: "minimoEntre" },
+   *    expected: false,
+   *  },
+   *  {
+   *    inspection: "HasBinding",
+   *    args: { name: "squareList" },
+   *    expected: true,
+   *  }
+   * ]
+   * const analyzer = new ASTAnalyzer(ast);
+   * const analysisResults = analyzer.analyze(expectations);
+   */
+  public analyze(ast: AST, rules: InspectionRule[]): AnalysisResult[] {
+    const ruleResults: Map<InspectionRule, AnalysisResult> = new Map();
+    const graphBuilder = new GraphBuilder();
+    const { defs, calls } = graphBuilder.build(ast);
+
+    for (const rule of rules) {
+      let inspectionName = rule.inspection;
+      let isTransitive = true;
+
+      if (inspectionName.startsWith("Intransitive:")) {
+        isTransitive = false;
+        inspectionName = inspectionName.replace("Intransitive:", "");
+      }
+
+      const InspectionClass = this.inspectionConstructors[inspectionName];
+      if (!InspectionClass) {
+        ruleResults.set(rule, {
+          rule,
+          passed: false,
+          actual: false,
+          error: "Unknown inspection: " + inspectionName,
+        });
+        continue;
+      }
+
+      if (InspectionClass.IS_INTRANSITIVE) isTransitive = false;
+
+      let targets: { node: any; binding?: string }[] = [];
+
+      // Case 1: Global Inspection (No binding or wildcard)
+      if (!rule.binding || rule.binding === "*") {
+        targets = ast.map((n) => ({ node: n, binding: undefined }));
+      }
+      // Case 2: Directed Inspection (Specific binding)
+      else {
+        const workList = [rule.binding];
+        const visited = new Set<string>();
+
+        while (workList.length > 0) {
+          const currentBinding = workList.shift();
+          if (!currentBinding || visited.has(currentBinding)) continue;
+          visited.add(currentBinding);
+
+          const node = defs.get(currentBinding);
+          if (node)
+            node.forEach((n) =>
+              targets.push({ node: n, binding: currentBinding }),
+            );
+
+          if (isTransitive) {
+            const deps = calls.get(currentBinding) || [];
+            workList.push(...deps);
+          }
+        }
+      }
+
+      let actual = false;
+      let error: string | undefined = undefined;
+
+      // Execution Loop
+      const isGlobalVisitor = !rule.binding || rule.binding === "*";
+      const normalizedBinding = isGlobalVisitor ? undefined : rule.binding;
+      const args = rule.args ?? [];
+      const visitor = new InspectionClass(...args, normalizedBinding);
+
+      for (const { node, binding } of targets) {
+        try {
+          if (!isGlobalVisitor && visitor.setBinding && binding) {
+            visitor.setBinding(binding);
+          }
+          node.accept(visitor);
+        } catch (e) {
+          if (e instanceof StopTraversalException) {
+            actual = true;
+            break; // Short-circuit: Rule passed
+          } else {
+            error = (e as Error).message;
+          }
+        }
+      }
+
+      ruleResults.set(rule, {
+        rule,
+        passed: actual === rule.expected,
+        actual,
+        error,
+      });
+    }
+    return [...ruleResults.values()];
+  }
+}

package/src/analyzer/inspections/functional/functional.ts

@@ -1,121 +1,121 @@
-import * as Yu from "yukigo-ast";
-import { VisitorConstructor, ScopedVisitor, AutoScoped } from "../../utils.js";
-
-@AutoScoped
-export class UsesComposition extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitCompositionExpression(node: Yu.CompositionExpression): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesAnonymousVariable extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitWildcardPattern(node: Yu.WildcardPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesComprehension extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitListComprehension(node: Yu.ListComprehension): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesGuards extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitGuardedBody(node: Yu.GuardedBody): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesOtherwise extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitOtherwise(node: Yu.Otherwise): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesLambda extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitLambda(node: Yu.Lambda): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesYield extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitYield(node: Yu.Yield): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-@AutoScoped
-export class UsesPatternMatching extends ScopedVisitor {
-  constructor(scope?: string) {
-    super(scope);
-  }
-  visitConsPattern(node: Yu.ConsPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitAsPattern(node: Yu.AsPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitListPattern(node: Yu.ListPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitTuplePattern(node: Yu.TuplePattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitLiteralPattern(node: Yu.LiteralPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitApplicationPattern(node: Yu.ApplicationPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitConstructorPattern(node: Yu.ConstructorPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitUnionPattern(node: Yu.UnionPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitFunctorPattern(node: Yu.FunctorPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-  visitWildcardPattern(node: Yu.WildcardPattern): void {
-    throw new Yu.StopTraversalException();
-  }
-}
-
-export const functionalInspections: Record<string, VisitorConstructor> = {
-  UsesComposition: UsesComposition,
-  HasComposition: UsesComposition,
-  UsesAnonymousVariable: UsesAnonymousVariable,
-  HasAnonymousVariable: UsesAnonymousVariable,
-  UsesComprehension: UsesComprehension,
-  HasComprehension: UsesComprehension,
-  UsesGuards: UsesGuards,
-  HasGuards: UsesGuards,
-  UsesOtherwise: UsesOtherwise,
-  HasOtherwise: UsesOtherwise,
-  UsesLambda: UsesLambda,
-  HasLambda: UsesLambda,
-  UsesYield: UsesYield,
-  HasYield: UsesYield,
-  UsesPatternMatching: UsesPatternMatching,
-  HasPatternMatching: UsesPatternMatching,
-};
+import * as Yu from "yukigo-ast";
+import { VisitorConstructor, ScopedVisitor, AutoScoped } from "../../utils.js";
+
+@AutoScoped
+export class UsesComposition extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitCompositionExpression(node: Yu.CompositionExpression): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesAnonymousVariable extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitWildcardPattern(node: Yu.WildcardPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesComprehension extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitListComprehension(node: Yu.ListComprehension): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesGuards extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitGuardedExpression(node: Yu.GuardedExpression): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesOtherwise extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitOtherwise(node: Yu.Otherwise): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesLambda extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitLambda(node: Yu.Lambda): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesYield extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitYield(node: Yu.Yield): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+@AutoScoped
+export class UsesPatternMatching extends ScopedVisitor {
+  constructor(scope?: string) {
+    super(scope);
+  }
+  visitConsPattern(node: Yu.ConsPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitAsPattern(node: Yu.AsPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitListPattern(node: Yu.ListPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitTuplePattern(node: Yu.TuplePattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitLiteralPattern(node: Yu.LiteralPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitApplicationPattern(node: Yu.ApplicationPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitConstructorPattern(node: Yu.ConstructorPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitUnionPattern(node: Yu.UnionPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitFunctorPattern(node: Yu.FunctorPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+  visitWildcardPattern(node: Yu.WildcardPattern): void {
+    throw new Yu.StopTraversalException();
+  }
+}
+
+export const functionalInspections: Record<string, VisitorConstructor> = {
+  UsesComposition: UsesComposition,
+  HasComposition: UsesComposition,
+  UsesAnonymousVariable: UsesAnonymousVariable,
+  HasAnonymousVariable: UsesAnonymousVariable,
+  UsesComprehension: UsesComprehension,
+  HasComprehension: UsesComprehension,
+  UsesGuards: UsesGuards,
+  HasGuards: UsesGuards,
+  UsesOtherwise: UsesOtherwise,
+  HasOtherwise: UsesOtherwise,
+  UsesLambda: UsesLambda,
+  HasLambda: UsesLambda,
+  UsesYield: UsesYield,
+  HasYield: UsesYield,
+  UsesPatternMatching: UsesPatternMatching,
+  HasPatternMatching: UsesPatternMatching,
+};