yukigo 0.2.3 → 0.3.2

package/src/analyzer/inspections/object/smells.ts

@@ -1,144 +1,130 @@
-import {
-  ASTNode,
-  Class,
-  Interface,
-  LogicalBinaryOperation,
-  Method,
-  NilPrimitive,
-  Object,
-  Return,
-  StopTraversalException,
-  StringPrimitive,
-  TraverseVisitor,
-} from "yukigo-ast";
-import { AutoScoped, ScopedVisitor, VisitorConstructor } from "../../utils.js";
-import { Uses } from "../generic/generic.js";
-
-class MethodCollector extends TraverseVisitor {
-  private collectedMethods: Method[] = [];
-  collect(node: Class | Object | Interface): Method[] {
-    node.expression.accept(this);
-    return this.collectedMethods;
-  }
-  visitMethod(node: Method) {
-    this.collectedMethods.push(node);
-  }
-}
-
-@AutoScoped
-export class DoesNilTest extends ScopedVisitor {
-  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
-    if (
-      node.left instanceof NilPrimitive ||
-      node.right instanceof NilPrimitive
-    ) {
-      throw new StopTraversalException();
-    }
-  }
-}
-
-@AutoScoped
-export class DoesTypeTest extends ScopedVisitor {
-  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
-    if (
-      node.left instanceof StringPrimitive ||
-      node.right instanceof StringPrimitive
-    ) {
-      throw new StopTraversalException();
-    }
-  }
-}
-
-@AutoScoped
-export class ReturnsNil extends ScopedVisitor {
-  visitReturn(node: Return): void {
-    if (!Boolean(node.body) || node.body instanceof NilPrimitive)
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class HasTooManyMethods extends ScopedVisitor {
-  private counter: number;
-  private readonly maxMethods: number;
-
-  constructor(maxMethods: number = 10, scopeName?: string) {
-    super(scopeName);
-    this.maxMethods = maxMethods;
-  }
-
-  visitInterface(node: Interface): void {
-    node.expression.accept(this);
-    this.checkMethodCount();
-    this.counter = 0;
-  }
-
-  visitClass(node: Class): void {
-    node.expression.accept(this);
-    this.checkMethodCount();
-    this.counter = 0;
-  }
-  visitObject(node: Object): void {
-    node.expression.accept(this);
-    this.checkMethodCount();
-    this.counter = 0;
-  }
-
-  visitMethod(node: Method): void {
-    this.counter += 1;
-  }
-
-  private checkMethodCount(): void {
-    if (this.counter > this.maxMethods) throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class OverridesEqualOrHashButNotBoth extends ScopedVisitor {
-  visitClass(node: Class): void {
-    const collector = new MethodCollector();
-    const methods = collector.collect(node);
-    const names = methods.map((m) => m.identifier.value);
-    const hasEquals =
-      names.includes("equals") ||
-      names.includes("==") ||
-      names.includes("eql?");
-
-    const hasHash = names.includes("hashCode") || names.includes("hash");
-
-    if ((hasEquals && !hasHash) || (!hasEquals && hasHash))
-      throw new StopTraversalException();
-  }
-}
-
-@AutoScoped
-export class UsesNamedSelfReference extends ScopedVisitor {
-  visitObject(node: Object): void {
-    this.checkSelfReference(node.identifier.value, node.expression);
-  }
-
-  visitClass(node: Class): void {
-    this.checkSelfReference(node.identifier.value, node.expression);
-  }
-
-  private checkSelfReference(selfName: string, body: ASTNode): void {
-    const checker = new Uses(selfName, this.binding);
-
-    try {
-      body.accept(checker);
-    } catch (e) {
-      if (e instanceof StopTraversalException)
-        throw new StopTraversalException();
-      throw e;
-    }
-  }
-}
-
-export const objectSmells: Record<string, VisitorConstructor> = {
-  DoesNilTest: DoesNilTest,
-  DoesTypeTest: DoesTypeTest,
-  HasTooManyMethods: HasTooManyMethods,
-  OverridesEqualOrHashButNotBoth: OverridesEqualOrHashButNotBoth,
-  ReturnsNil: ReturnsNil,
-  UsesNamedSelfReference: UsesNamedSelfReference,
-};
+import {
+  ASTNode,
+  Class,
+  Interface,
+  LogicalBinaryOperation,
+  Method,
+  NilPrimitive,
+  Object,
+  Return,
+  StopTraversalException,
+  StringPrimitive,
+} from "yukigo-ast";
+import {
+  AutoScoped,
+  InspectionVisitor,
+  ScopedVisitor,
+  VisitorConstructor,
+} from "../../utils.js";
+import { Uses } from "../generic/generic.js";
+
+class MethodCollector extends InspectionVisitor {
+  private collectedMethods: Method[] = [];
+  collect(node: Class | Object | Interface): Method[] {
+    node.expression.accept(this);
+    return this.collectedMethods;
+  }
+  visitMethod(node: Method) {
+    this.collectedMethods.push(node);
+  }
+}
+
+@AutoScoped
+export class DoesNilTest extends ScopedVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    if (node.left.is(NilPrimitive) || node.right.is(NilPrimitive))
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class DoesTypeTest extends ScopedVisitor {
+  visitLogicalBinaryOperation(node: LogicalBinaryOperation): void {
+    if (node.left.is(StringPrimitive) || node.right.is(StringPrimitive)) {
+      throw new StopTraversalException();
+    }
+  }
+}
+
+@AutoScoped
+export class ReturnsNil extends ScopedVisitor {
+  visitReturn(node: Return): void {
+    if (!node.body || node.body.is(NilPrimitive))
+      throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class HasTooManyMethods extends ScopedVisitor {
+  private counter: number = 0;
+  private readonly maxMethods: number;
+
+  constructor(maxMethods: number = 10, scopeName?: string) {
+    super(scopeName);
+    this.maxMethods = maxMethods;
+  }
+
+  visitInterface(node: Interface): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+
+  visitClass(node: Class): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+  visitObject(node: Object): void {
+    node.expression.accept(this);
+    this.checkMethodCount();
+    this.counter = 0;
+  }
+
+  visitMethod(node: Method): void {
+    this.counter += 1;
+  }
+
+  private checkMethodCount(): void {
+    if (this.counter > this.maxMethods) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class OverridesEqualOrHashButNotBoth extends ScopedVisitor {
+  visitClass(node: Class): void {
+    const collector = new MethodCollector();
+    const methods = collector.collect(node);
+    const names = methods.map((m) => m.identifier.value);
+
+    const hasEquals = names.some((n) => ["equals", "==", "eql?"].includes(n));
+    const hasHash = names.some((n) => ["hashCode", "hash"].includes(n));
+
+    if (hasEquals !== hasHash) throw new StopTraversalException();
+  }
+}
+
+@AutoScoped
+export class UsesNamedSelfReference extends ScopedVisitor {
+  visitObject(node: Object): void {
+    this.checkSelfReference(node.identifier.value, node.expression);
+  }
+
+  visitClass(node: Class): void {
+    this.checkSelfReference(node.identifier.value, node.expression);
+  }
+
+  private checkSelfReference(selfName: string, body: ASTNode): void {
+    const checker = new Uses(selfName, this.binding);
+    body.accept(checker);
+  }
+}
+
+export const objectSmells: Record<string, VisitorConstructor> = {
+  DoesNilTest: DoesNilTest,
+  DoesTypeTest: DoesTypeTest,
+  HasTooManyMethods: HasTooManyMethods,
+  OverridesEqualOrHashButNotBoth: OverridesEqualOrHashButNotBoth,
+  ReturnsNil: ReturnsNil,
+  UsesNamedSelfReference: UsesNamedSelfReference,
+};

package/src/analyzer/utils.ts

@@ -1,109 +1,115 @@
-import {
-  Class,
-  Fact,
-  Function,
-  Method,
-  Object as YuObject,
-  Procedure,
-  Rule,
-  TraverseVisitor,
-  Variable,
-  ASTNode,
-} from "yukigo-ast";
-
-export interface VisitorConstructor {
-  new (...args: any[]): TraverseVisitor & { setBinding?(binding: string): void };
-  IS_INTRANSITIVE?: boolean;
-}
-export type InspectionMap = Record<string, VisitorConstructor>;
-
-type TopNode =
-  | Variable
-  | Function
-  | Class
-  | YuObject
-  | Method
-  | Rule
-  | Fact
-  | Procedure;
-export class ScopedVisitor extends TraverseVisitor {
-  protected binding?: string;
-  public inScope: boolean;
-
-  constructor(binding?: string) {
-    super();
-    this.setBinding(binding)
-  }
-
-  setBinding(binding?: string) {
-    this.binding = binding;
-    this.inScope = !binding;
-  }
-  
-
-  visitVariable(node: Variable): void {
-    this.manageScope(node, () => super.visitVariable(node));
-  }
-  visitFunction(node: Function): void {
-    this.manageScope(node, () => super.visitFunction(node));
-  }
-  visitClass(node: Class): void {
-    this.manageScope(node, () => super.visitClass(node));
-  }
-  visitObject(node: YuObject): void {
-    this.manageScope(node, () => super.visitObject(node));
-  }
-  visitMethod(node: Method): void {
-    this.manageScope(node, () => super.visitMethod(node));
-  }
-  visitRule(node: Rule): void {
-    this.manageScope(node, () => super.visitRule(node));
-  }
-  visitFact(node: Fact): void {
-    this.manageScope(node, () => super.visitFact(node));
-  }
-  visitProcedure(node: Procedure): void {
-    this.manageScope(node, () => super.visitProcedure(node));
-  }
-
-  private manageScope(node: TopNode, traverse: () => void) {
-    const isTarget = node.identifier.value === this.binding;
-    if (isTarget) this.inScope = true;
-    traverse();
-    if (isTarget) this.inScope = false;
-  }
-}
-
-export function AutoScoped<T extends { new (...args: any[]): any }>(
-  constructor: T
-) {
-  const proto = constructor.prototype;
-  const methodNames = Object.getOwnPropertyNames(proto);
-
-  for (const name of methodNames) {
-    if (isValidVisitMethod(name)) {
-      const originalMethod = proto[name];
-
-      // replace the method on the prototype
-      proto[name] = function (this: any, node: ASTNode) {
-        if (!this.inScope) return;
-        // run the inspection logic if in scope
-        return originalMethod.call(this, node);
-      };
-    }
-  }
-}
-function isScopeBoundary(name: string): boolean {
-  return [
-    "visitFunction",
-    "visitMethod",
-    "visitProcedure",
-    "visitRule",
-    "visitFact",
-    "visitVariable",
-    "visitClass",
-    "visitObject",
-  ].includes(name);
-}
-const isValidVisitMethod = (name: string) =>
-  name.startsWith("visit") && name !== "constructor" && !isScopeBoundary(name);
+import {
+  Class,
+  Fact,
+  Function,
+  Method,
+  Object as YuObject,
+  Procedure,
+  Rule,
+  TraverseVisitor,
+  Variable,
+  ASTNode,
+} from "yukigo-ast";
+
+export class InspectionVisitor extends TraverseVisitor {
+  public fallback(node: ASTNode): void {}
+}
+
+export interface VisitorConstructor {
+  new (
+    ...args: any[]
+  ): TraverseVisitor & { setBinding?(binding: string): void };
+  IS_INTRANSITIVE?: boolean;
+}
+export type InspectionMap = Record<string, VisitorConstructor>;
+
+type TopNode =
+  | Variable
+  | Function
+  | Class
+  | YuObject
+  | Method
+  | Rule
+  | Fact
+  | Procedure;
+export class ScopedVisitor extends InspectionVisitor {
+  protected binding?: string;
+  public inScope: boolean = false;
+
+  constructor(binding?: string) {
+    super();
+    this.setBinding(binding);
+  }
+
+  setBinding(binding?: string) {
+    this.binding = binding;
+    this.inScope = !binding;
+  }
+
+  visitVariable(node: Variable): void {
+    this.manageScope(node, () => super.visitVariable(node));
+  }
+  visitFunction(node: Function): void {
+    this.manageScope(node, () => super.visitFunction(node));
+  }
+  visitClass(node: Class): void {
+    this.manageScope(node, () => super.visitClass(node));
+  }
+  visitObject(node: YuObject): void {
+    this.manageScope(node, () => super.visitObject(node));
+  }
+  visitMethod(node: Method): void {
+    this.manageScope(node, () => super.visitMethod(node));
+  }
+  visitRule(node: Rule): void {
+    this.manageScope(node, () => super.visitRule(node));
+  }
+  visitFact(node: Fact): void {
+    this.manageScope(node, () => super.visitFact(node));
+  }
+  visitProcedure(node: Procedure): void {
+    this.manageScope(node, () => super.visitProcedure(node));
+  }
+  public fallback(node: ASTNode): void {}
+
+  private manageScope(node: TopNode, traverse: () => void) {
+    const isTarget = node.identifier.value === this.binding;
+    if (isTarget) this.inScope = true;
+    traverse();
+    if (isTarget) this.inScope = false;
+  }
+}
+
+export function AutoScoped<T extends { new (...args: any[]): any }>(
+  constructor: T,
+) {
+  const proto = constructor.prototype;
+  const methodNames = Object.getOwnPropertyNames(proto);
+
+  for (const name of methodNames) {
+    if (isValidVisitMethod(name)) {
+      const originalMethod = proto[name];
+
+      // replace the method on the prototype
+      proto[name] = function (this: any, node: ASTNode) {
+        if (!this.inScope) return;
+        // run the inspection logic if in scope
+        return originalMethod.call(this, node);
+      };
+    }
+  }
+}
+function isScopeBoundary(name: string): boolean {
+  return [
+    "visitFunction",
+    "visitMethod",
+    "visitProcedure",
+    "visitRule",
+    "visitFact",
+    "visitVariable",
+    "visitClass",
+    "visitObject",
+  ].includes(name);
+}
+const isValidVisitMethod = (name: string) =>
+  name.startsWith("visit") && name !== "constructor" && !isScopeBoundary(name);

package/src/index.ts

@@ -1,4 +1,4 @@
-export * from "./interpreter/index.js";
-export * from "./analyzer/index.js";
-export * from "./tester/index.js";
+export * from "./interpreter/index.js";
+export * from "./analyzer/index.js";
+export * from "./tester/index.js";
 export * from "./utils/helpers.js";