yukigo 0.1.0

package/tests/analyzer/logic.spec.ts

@@ -0,0 +1,292 @@
+import { expect } from "chai";
+import {
+  Fact,
+  Rule,
+  SymbolPrimitive,
+  Exist,
+  Not,
+  Forall,
+  Findall,
+  AssignOperation,
+  UnifyOperation,
+  NumberPrimitive,
+  ASTNode,
+  StopTraversalException,
+  ArithmeticBinaryOperation,
+} from "yukigo-ast";
+import {
+  DeclaresFact,
+  DeclaresRule,
+  DeclaresPredicate,
+  UsesFindall,
+  UsesForall,
+  UsesNot,
+  UsesUnificationOperator,
+  UsesCut,
+  UsesFail,
+  HasRedundantReduction,
+} from "../../src/analyzer/inspections/logic.js";
+
+function executeVisitor(node: ASTNode | ASTNode[], visitor: any) {
+  if (Array.isArray(node)) {
+    node.forEach((n) => n.accept(visitor));
+  } else {
+    node.accept(visitor);
+  }
+}
+
+describe("Logic Spec", () => {
+  const createSymbol = (name: string) => new SymbolPrimitive(name);
+  const createNumber = (val: number) => new NumberPrimitive(val);
+
+  const createFact = (name: string, args: any[] = []) => {
+    return new Fact(createSymbol(name), args);
+  };
+
+  const createRule = (
+    name: string,
+    patterns: any[] = [],
+    bodyExprs: any[] = []
+  ) => {
+    return new Rule(createSymbol(name), patterns, bodyExprs);
+  };
+
+  const createCall = (name: string, args: any[] = []) => {
+    return new Exist(createSymbol(name), args);
+  };
+
+  describe("DeclaresFact", () => {
+    it("detects when a specific fact is declared", () => {
+      const fact = createFact("baz", [createSymbol("a")]);
+      const visitor = new DeclaresFact("baz");
+      expect(() => executeVisitor(fact, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("ignores facts with different names", () => {
+      const fact = createFact("baz");
+      const visitor = new DeclaresFact("foo");
+      expect(() => executeVisitor(fact, visitor)).to.not.throw();
+    });
+  });
+
+  describe("DeclaresRule", () => {
+    it("detects when a specific rule is declared", () => {
+      const rule = createRule("foo");
+      const visitor = new DeclaresRule("foo");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("ignores rules with different names", () => {
+      const rule = createRule("foo");
+      const visitor = new DeclaresRule("baz");
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+
+  describe("DeclaresPredicate", () => {
+    it("is True when rule is declared", () => {
+      const rule = createRule("foo");
+      const visitor = new DeclaresPredicate("foo");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is True when fact is declared", () => {
+      const fact = createFact("foo");
+      const visitor = new DeclaresPredicate("foo");
+      expect(() => executeVisitor(fact, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when predicate is not declared", () => {
+      const fact = createFact("bar");
+      const visitor = new DeclaresPredicate("foo");
+      expect(() => executeVisitor(fact, visitor)).to.not.throw();
+    });
+  });
+
+  describe("UsesForall", () => {
+    it("detects usage of forall/2", () => {
+      const forallNode = new Forall(createCall("cond"), createCall("action"));
+      const rule = createRule("foo", [], [forallNode]);
+
+      const visitor = new UsesForall();
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when not used", () => {
+      const rule = createRule("foo", [], [createCall("bar")]);
+      const visitor = new UsesForall();
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+
+  describe("UsesFindall", () => {
+    it("detects usage of findall/3", () => {
+      const findallNode = new Findall(
+        createSymbol("X"),
+        createCall("goal"),
+        createSymbol("L")
+      );
+      const rule = createRule("foo", [], [findallNode]);
+
+      const visitor = new UsesFindall();
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+  });
+
+  describe("UsesNot", () => {
+    it("detects usage of Not node", () => {
+      const notNode = new Not([createCall("g")]);
+      const rule = createRule("foo", [], [notNode]);
+
+      const visitor = new UsesNot();
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("detects usage of 'not' as an Exist call (legacy/parsing variant)", () => {
+      const notCall = createCall("not", [createCall("g")]);
+      const rule = createRule("foo", [], [notCall]);
+
+      const visitor = new UsesNot();
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when not used", () => {
+      const rule = createRule("foo", [], [createCall("bar")]);
+      const visitor = new UsesNot();
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+
+  describe("UsesUnificationOperator", () => {
+    it("detects usage of unification (=)", () => {
+      const unify = new UnifyOperation(
+        "Unify",
+        createSymbol("X"),
+        createNumber(4)
+      );
+      const rule = createRule("baz", [], [unify]);
+
+      const visitor = new UsesUnificationOperator("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when no equal", () => {
+      const rule = createRule("baz", [], [createCall("other")]);
+      const visitor = new UsesUnificationOperator("baz");
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+
+  describe("UsesCut", () => {
+    it("detects usage of cut (!)", () => {
+      const cut = createCall("!");
+      const rule = createRule("baz", [], [cut]);
+
+      const visitor = new UsesCut("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when not used", () => {
+      const rule = createRule("baz");
+      const visitor = new UsesCut("baz");
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+
+  describe("UsesFail", () => {
+    it("detects usage of fail", () => {
+      const failNode = createCall("fail");
+      const rule = createRule("baz", [], [failNode]);
+
+      const visitor = new UsesFail("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+  });
+
+  describe("HasRedundantReduction", () => {
+    it("is True when there is a redundant reduction of parameters (Var is Var)", () => {
+      const assign = new AssignOperation(
+        "Assign",
+        createSymbol("X"),
+        createSymbol("Y")
+      );
+      const rule = createRule("baz", [], [assign]);
+
+      const visitor = new HasRedundantReduction("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is True when there is a redundant reduction of literals (Var is 5)", () => {
+      const assign = new AssignOperation(
+        "Assign",
+        createSymbol("X"),
+        createNumber(5)
+      );
+      const rule = createRule("baz", [], [assign]);
+
+      const visitor = new HasRedundantReduction("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is True when there is a redundant reduction of functors (Var is struct)", () => {
+      const functor = createCall("aFunctor", [createNumber(5)]);
+      const assign = new AssignOperation("Assign", createSymbol("Z"), functor);
+      const rule = createRule("baz", [], [assign]);
+
+      const visitor = new HasRedundantReduction("baz");
+      expect(() => executeVisitor(rule, visitor)).to.throw(
+        StopTraversalException
+      );
+    });
+
+    it("is False when there is a complex reduction (operators)", () => {
+      const assign = new AssignOperation(
+        "Assign",
+        createSymbol("X"),
+        new ArithmeticBinaryOperation("Plus", createNumber(3), createNumber(2))
+      );
+      const rule = createRule("baz", [], [assign]);
+
+      const visitor = new HasRedundantReduction("baz");
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+
+    it("respects bindings checks", () => {
+      const assign = new AssignOperation(
+        "Assign",
+        createSymbol("X"),
+        createNumber(5)
+      );
+      const rule = createRule("other", [], [assign]);
+
+      const visitor = new HasRedundantReduction("baz");
+      expect(() => executeVisitor(rule, visitor)).to.not.throw();
+    });
+  });
+});

package/tests/analyzer/oop.spec.ts

@@ -0,0 +1,338 @@
+import { expect } from "chai";
+import {
+  Class,
+  Method,
+  Send,
+  Self,
+  SymbolPrimitive,
+  Attribute,
+  New,
+  Include,
+  Interface,
+  Object as AstObject,
+  PrimitiveMethod,
+  Implement,
+  ASTNode,
+  Equation,
+  UnguardedBody,
+  Sequence,
+  NilPrimitive,
+  Statement,
+  Print,
+  StringPrimitive,
+} from "yukigo-ast";
+import {
+  DeclaresAttribute,
+  DeclaresClass,
+  DeclaresInterface,
+  DeclaresMethod,
+  DeclaresObject,
+  DeclaresPrimitive,
+  DeclaresSuperclass,
+  Implements,
+  IncludeMixin,
+  Instantiates,
+  UsesDynamicPolymorphism,
+  UsesInheritance,
+  UsesMixins,
+  UsesObjectComposition,
+  UsesStaticMethodOverload,
+  UsesDynamicMethodOverload,
+  UsesTemplateMethod,
+} from "../../src/analyzer/inspections/object.js";
+import { executeVisitor } from "../../src/analyzer/utils.js";
+
+describe("OOP Spec", () => {
+  const createSymbol = (name: string) => new SymbolPrimitive(name);
+  const createMethod = (
+    name: string,
+    equationsCount: number = 1,
+    isAbstract: boolean = false,
+    bodyNode?: Statement
+  ): Method => {
+    const identifier = createSymbol(name);
+    const stmts = bodyNode ? [bodyNode] : [];
+    const equations = new Array(equationsCount).fill(
+      new Equation([], new UnguardedBody(new Sequence(stmts)))
+    );
+    const method = new Method(identifier, equations);
+    method.setMetadata("isAbstract", isAbstract);
+    return method;
+  };
+
+  const createAttribute = (
+    name: string,
+    expression: any = new NilPrimitive(null)
+  ) => {
+    return new Attribute(createSymbol(name), expression);
+  };
+
+  const createNew = (className: string) => {
+    return new New(createSymbol(className), []);
+  };
+
+  const createClass = (
+    name: string,
+    stmts: Statement[] = [],
+    extendsName?: string,
+    implementsName?: string
+  ): Class => {
+    const identifier = createSymbol(name);
+    const extendsSymbol = extendsName ? createSymbol(extendsName) : undefined;
+    const implementsNode = implementsName
+      ? new Implement(createSymbol(implementsName))
+      : undefined;
+
+    const expression = new Sequence(stmts);
+
+    return new Class(identifier, extendsSymbol, implementsNode, expression);
+  };
+
+  const createObject = (name: string, children: ASTNode[] = []) => {
+    const identifier = createSymbol(name);
+    const expression = {
+      accept: (visitor: any) => {
+        children.forEach((child) => child.accept(visitor));
+      },
+      toJSON: () => ({}),
+    } as any;
+    return new AstObject(identifier, expression);
+  };
+
+  describe("DeclaresAttribute", () => {
+    it("should detect if an attribute with the specific name is declared", () => {
+      const attr = createAttribute("energy");
+      const visitor = new DeclaresAttribute("energy");
+      expect(executeVisitor(attr, visitor)).to.eq(true);
+    });
+
+    it("should ignore attributes with different names", () => {
+      const attr = createAttribute("life");
+      const visitor = new DeclaresAttribute("energy");
+      expect(executeVisitor(attr, visitor)).to.eq(false);
+    });
+  });
+
+  describe("DeclaresClass", () => {
+    it("should detect specific class declaration", () => {
+      const node = createClass("Bird");
+      const visitor = new DeclaresClass("Bird");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("DeclaresInterface", () => {
+    it("should detect specific interface declaration", () => {
+      const node = new Interface(createSymbol("Flyable"), [], {} as any);
+      const visitor = new DeclaresInterface("Flyable");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("DeclaresMethod", () => {
+    it("should detect specific method declaration", () => {
+      const node = createMethod("fly");
+      const visitor = new DeclaresMethod("fly");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("DeclaresObject", () => {
+    it("should detect specific object declaration", () => {
+      const node = createObject("pepita");
+      const visitor = new DeclaresObject("pepita");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("DeclaresPrimitive", () => {
+    it("should detect primitive operator override", () => {
+      const op: any = "==";
+      const node = new PrimitiveMethod(op, [], undefined as any);
+      const visitor = new DeclaresPrimitive("==");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("DeclaresSuperclass", () => {
+    it("should detect if a class extends a specific superclass", () => {
+      const node = createClass("Sparrow", [], "Bird");
+      const visitor = new DeclaresSuperclass("Bird");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("Implements", () => {
+    it("should detect if a class implements a specific interface", () => {
+      const node = createClass("Pigeon", [], undefined, "Messenger");
+      const visitor = new Implements("Messenger");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("IncludeMixin", () => {
+    it("should detect usage of a specific mixin", () => {
+      const node = new Include(createSymbol("Walking"));
+      const visitor = new IncludeMixin("Walking");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("Instantiates", () => {
+    it("should detect instantiation of a specific class", () => {
+      const node = createNew("Engine");
+      const visitor = new Instantiates("Engine");
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("UsesDynamicPolymorphism", () => {
+    it("should detect when a method name is used in at least two different places (polymorphism)", () => {
+      const method1 = createMethod("fly");
+      const method2 = createMethod("fly");
+
+      const class1 = createClass("Bird", [method1]);
+      const class2 = createClass("Airplane", [method2]);
+
+      const visitor = new UsesDynamicPolymorphism("fly");
+
+      executeVisitor(class1, visitor);
+
+      expect(executeVisitor(class2, visitor)).to.eq(true);
+    });
+
+    it("should not throw if only one method is found", () => {
+      const method1 = createMethod("fly");
+      const class1 = createClass("Bird", [method1]);
+      const visitor = new UsesDynamicPolymorphism("fly");
+
+      expect(executeVisitor(class1, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesInheritance", () => {
+    it("should detect inheritance in classes", () => {
+      const node = createClass("Child", [], "Parent");
+      const visitor = new UsesInheritance();
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should detect inheritance in interfaces", () => {
+      const node = new Interface(
+        createSymbol("IChild"),
+        [createSymbol("IParent")],
+        {} as any
+      );
+      const visitor = new UsesInheritance();
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+
+    it("should ignore classes without parent", () => {
+      const node = createClass("Orphan");
+      const visitor = new UsesInheritance();
+      expect(executeVisitor(node, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesMixins", () => {
+    it("should detect any mixin usage", () => {
+      const node = new Include(createSymbol("AnyMixin"));
+      const visitor = new UsesMixins();
+      expect(executeVisitor(node, visitor)).to.eq(true);
+    });
+  });
+
+  describe("UsesObjectComposition", () => {
+    it("should detect composition when an attribute is initialized with New", () => {
+      const instantiation = createNew("Engine");
+      const attr = createAttribute("myEngine", instantiation);
+      const visitor = new UsesObjectComposition();
+      expect(executeVisitor(attr, visitor)).to.eq(true);
+    });
+
+    it("should ignore attributes initialized with literals", () => {
+      const attr = createAttribute(
+        "energy",
+        new StringPrimitive("Initialized with string!")
+      );
+      const visitor = new UsesObjectComposition();
+      expect(executeVisitor(attr, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesStaticMethodOverload", () => {
+    it("should detect two methods with the same name in the same class", () => {
+      const m1 = createMethod("calculate");
+      const m2 = createMethod("calculate");
+      const classNode = createClass("Calculator", [m1, m2]);
+
+      const visitor = new UsesStaticMethodOverload();
+      expect(executeVisitor(classNode, visitor)).to.eq(true);
+    });
+
+    it("should NOT detect overload if methods are in different classes", () => {
+      const m1 = createMethod("calculate");
+      const m2 = createMethod("calculate");
+
+      const classA = createClass("A", [m1]);
+      const classB = createClass("B", [m2]);
+
+      const visitor = new UsesStaticMethodOverload();
+
+      executeVisitor(classA, visitor);
+
+      expect(executeVisitor(classB, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesDynamicMethodOverload", () => {
+    it("should detect a method with multiple equations (pattern matching)", () => {
+      const method = createMethod("fibonacci", 2);
+      const visitor = new UsesDynamicMethodOverload();
+      expect(executeVisitor(method, visitor)).to.eq(true);
+    });
+
+    it("should ignore methods with a single equation", () => {
+      const method = createMethod("fibonacci", 1);
+      const visitor = new UsesDynamicMethodOverload();
+      expect(executeVisitor(method, visitor)).to.eq(false);
+    });
+  });
+
+  describe("UsesTemplateMethod", () => {
+    it("should detect template method usage (call to undeclared method on self)", () => {
+      const declaredMethod = createMethod("abstractMethod", 1, true);
+      const sendToSelf = new Send(
+        new Self(),
+        createSymbol("abstractMethod"),
+        []
+      );
+
+      const templateMethod = createMethod("process", 1, false, sendToSelf);
+      const classNode = createClass("MyClass", [
+        declaredMethod,
+        templateMethod,
+      ]);
+
+      const visitor = new UsesTemplateMethod();
+      expect(executeVisitor(classNode, visitor)).to.eq(true);
+    });
+
+    it("should NOT detect if calling a declared method on self", () => {
+      const declaredMethod = createMethod(
+        "declared",
+        1,
+        false,
+        new Print(new StringPrimitive("This method is Declared"))
+      );
+      const sendToSelf = new Send(new Self(), createSymbol("declared"), []);
+
+      const method = createMethod("process", 1, false, sendToSelf);
+
+      const classNode = createClass("MyClass", [declaredMethod, method]);
+
+      const visitor = new UsesTemplateMethod();
+      expect(executeVisitor(classNode, visitor)).to.eq(false);
+    });
+  });
+});