yukigo 0.1.0 → 0.2.0

package/tests/analyzer/transitive.spec.ts

@@ -0,0 +1,166 @@
+import { expect } from "chai";
+import {
+  Function,
+  SymbolPrimitive,
+  Application,
+  Equation,
+  UnguardedBody,
+  Sequence,
+  AST,
+  Rule,
+  Exist,
+} from "yukigo-ast";
+import { Analyzer, InspectionRule } from "../../src/analyzer/index.js";
+import { AutoScoped, ScopedVisitor } from "../../src/analyzer/utils.js";
+
+// records which functions it visits
+@AutoScoped
+class SpyVisitor extends ScopedVisitor {
+  public static visited: string[] = [];
+
+  constructor(scope?: string) {
+    super(scope);
+  }
+
+  visitFunction(node: Function): void {
+    SpyVisitor.visited.push(node.identifier.value);
+  }
+
+  visitRule(node: Rule): void {
+    SpyVisitor.visited.push(node.identifier.value);
+  }
+}
+
+describe("Analyzer Transitive Behavior", () => {
+  let analyzer: Analyzer;
+
+  beforeEach(() => {
+    SpyVisitor.visited = [];
+    analyzer = new Analyzer();
+    analyzer.registerInspection("Spy", SpyVisitor);
+  });
+
+  const createFunction = (name: string, calls: string[] = []) => {
+    const identifier = new SymbolPrimitive(name);
+    const body = new Sequence(
+      calls.map(
+        (callee) =>
+          new Application(
+            new SymbolPrimitive(callee),
+            new SymbolPrimitive("arg")
+          )
+      )
+    );
+    const equation = new Equation([], new UnguardedBody(body));
+    return new Function(identifier, [equation]);
+  };
+
+  const createRule = (name: string, calls: string[] = []) => {
+    const identifier = new SymbolPrimitive(name);
+    const body = new Sequence(
+      calls.map((callee) => new Exist(new SymbolPrimitive(callee), []))
+    );
+    const equation = new Equation([], new UnguardedBody(body));
+    return new Rule(identifier, [equation]);
+  };
+
+  const runInspection = (
+    ast: AST,
+    binding: string,
+    inspectionName: string = "Spy"
+  ) => {
+    const rule: InspectionRule = {
+      inspection: inspectionName,
+      binding,
+      args: [],
+      expected: true,
+    };
+    analyzer.analyze(ast, [rule]);
+  };
+
+  it("should traverse dependencies transitively by default", () => {
+    // A -> B
+    const funcA = createFunction("A", ["B"]);
+    const funcB = createFunction("B", []);
+    const ast = [funcA, funcB];
+
+    runInspection(ast, "A", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A", "B"]);
+  });
+
+  it("should traverse deep dependencies", () => {
+    // A -> B -> C
+    const funcA = createFunction("A", ["B"]);
+    const funcB = createFunction("B", ["C"]);
+    const funcC = createFunction("C", []);
+    const ast = [funcA, funcB, funcC];
+
+    runInspection(ast, "A", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A", "B", "C"]);
+  });
+
+  it("should handle cycles gracefully", () => {
+    // A -> B -> A
+    const funcA = createFunction("A", ["B"]);
+    const funcB = createFunction("B", ["A"]);
+    const ast = [funcA, funcB];
+
+    runInspection(ast, "A", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A", "B"]);
+  });
+
+  it("should NOT traverse dependencies if Intransitive prefix is used", () => {
+    // A -> B
+    const funcA = createFunction("A", ["B"]);
+    const funcB = createFunction("B", []);
+    const ast = [funcA, funcB];
+
+    runInspection(ast, "A", "Intransitive:Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A"]);
+    expect(SpyVisitor.visited).to.not.include("B");
+  });
+
+  it("should not visit unreachable nodes", () => {
+    // A -> B; C (isolated)
+    const funcA = createFunction("A", ["B"]);
+    const funcB = createFunction("B", []);
+    const funcC = createFunction("C", []);
+    const ast = [funcA, funcB, funcC];
+
+    runInspection(ast, "A", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A", "B"]);
+    expect(SpyVisitor.visited).to.not.include("C");
+  });
+
+  it("should handle diamond dependencies correctly and visit each node once", () => {
+    // A -> B, A -> C, B -> D, C -> D
+    const funcA = createFunction("A", ["B", "C"]);
+    const funcB = createFunction("B", ["D"]);
+    const funcC = createFunction("C", ["D"]);
+    const funcD = createFunction("D", []);
+    const ast = [funcA, funcB, funcC, funcD];
+
+    runInspection(ast, "A", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["A", "B", "C", "D"]);
+
+    // Ensure no duplicates
+    expect(SpyVisitor.visited.length).to.equal(4);
+  });
+
+  it("should traverse dependencies in Logic Rules (Exist nodes)", () => {
+    // ruleA :- ruleB.
+    const ruleA = createRule("ruleA", ["ruleB"]);
+    const ruleB = createRule("ruleB", []);
+    const ast = [ruleA, ruleB];
+
+    runInspection(ast, "ruleA", "Spy");
+
+    expect(SpyVisitor.visited).to.include.members(["ruleA", "ruleB"]);
+  });
+});

package/tests/interpreter/EnvBuilder.spec.ts

@@ -1,178 +1,183 @@
-import { expect } from 'chai';
-import {
-  Function as AstFunction,
-  Fact,
-  Rule,
-  SymbolPrimitive,
-  Equation,
-} from 'yukigo-ast';
-import { EnvBuilderVisitor } from '../../src/interpreter/components/EnvBuilder.js';
-
-const id = (val: string) => ({ value: val } as SymbolPrimitive);
-
-const makeEq = (arity: number): Equation => ({
-  patterns: new Array(arity).fill({ type: 'MockPattern' }), // Relleno dummy
-  body: { type: 'MockBody' } as any
-} as any);
-
-const makeFunc = (name: string, arity: number, eqCount: number = 1): AstFunction => ({
-  type: 'Function',
-  identifier: id(name),
-  equations: new Array(eqCount).fill(null).map(() => makeEq(arity)),
-  accept: (v: any) => v.visitFunction(makeFunc(name, arity, eqCount))
-} as any);
-
-const makeFact = (name: string): Fact => ({
-  type: 'Fact',
-  identifier: id(name),
-  patterns: [],
-  accept: (v: any) => v.visitFact(makeFact(name))
-} as any);
-
-const makeRule = (name: string): Rule => ({
-  type: 'Rule',
-  identifier: id(name),
-  patterns: [],
-  expressions: [],
-  accept: (v: any) => v.visitRule(makeRule(name))
-} as any);
-
-describe('EnvBuilderVisitor', () => {
-  let visitor: EnvBuilderVisitor;
-  let env: Map<string, any>;
-
-  beforeEach(() => {
-    const initialStack = [new Map<string, any>()];
-    visitor = new EnvBuilderVisitor(initialStack);
-    env = initialStack[0];
-  });
-
-  describe('Function Declarations', () => {
-    it('should register a valid function', () => {
-      const funcNode = makeFunc('myFunc', 1);
-      
-      visitor.visitFunction(funcNode);
-
-      expect(env.has('myFunc')).to.be.true;
-      const entry = env.get('myFunc');
-      
-      expect(entry).to.have.property('identifier', 'myFunc');
-      expect(entry).to.have.property('arity', 1);
-      expect(entry.equations).to.have.lengthOf(1);
-    });
-
-    it('should register a function with multiple equations', () => {
-      const funcNode = makeFunc('fib', 1, 2);
-      
-      visitor.visitFunction(funcNode);
-      
-      const entry = env.get('fib');
-      expect(entry.equations).to.have.lengthOf(2);
-    });
-
-    it('should throw error if function has no equations', () => {
-      const funcNode = makeFunc('empty', 0, 0);
-      
-      expect(() => visitor.visitFunction(funcNode))
-        .to.throw(/has no equations/);
-    });
-
-    it('should throw error if equations have different arity', () => {
-      const funcNode = makeFunc('badFunc', 1);
-      funcNode.equations.push(makeEq(2));
-
-      expect(() => visitor.visitFunction(funcNode))
-        .to.throw(/must have the same arity/);
-    });
-  });
-
-  describe('Logic Programming (Facts)', () => {
-    it('should register a new Fact', () => {
-      const factNode = makeFact('parent');
-      
-      visitor.visitFact(factNode);
-
-      expect(env.has('parent')).to.be.true;
-      const entry = env.get('parent');
-      expect(entry).to.have.property('kind', 'Fact');
-      expect(entry.equations).to.have.lengthOf(1);
-      expect(entry.equations[0]).to.equal(factNode);
-    });
-
-    it('should append to existing Fact if identifier exists', () => {
-      const fact1 = makeFact('parent');
-      const fact2 = makeFact('parent');
-
-      visitor.visitFact(fact1);
-      visitor.visitFact(fact2);
-
-      const entry = env.get('parent');
-      expect(entry.kind).to.equal('Fact');
-      expect(entry.equations).to.have.lengthOf(2);
-      expect(entry.equations[0]).to.equal(fact1);
-      expect(entry.equations[1]).to.equal(fact2);
-    });
-
-    it('should overwrite existing entry if it is not a Fact', () => {
-      env.set('test', { kind: 'SomethingElse', equations: [] });
-
-      const fact = makeFact('test');
-      visitor.visitFact(fact);
-
-      const entry = env.get('test');
-      expect(entry.kind).to.equal('Fact');
-      expect(entry.equations).to.have.lengthOf(1);
-    });
-  });
-
-  describe('Logic Programming (Rules)', () => {
-    it('should register a new Rule', () => {
-      const ruleNode = makeRule('grandparent');
-      
-      visitor.visitRule(ruleNode);
-
-      expect(env.has('grandparent')).to.be.true;
-      const entry = env.get('grandparent');
-      expect(entry).to.have.property('kind', 'Rule');
-      expect(entry.equations).to.have.lengthOf(1);
-    });
-
-    it('should append to existing Rule group', () => {
-      const rule1 = makeRule('ancestor');
-      const rule2 = makeRule('ancestor');
-
-      visitor.visitRule(rule1);
-      visitor.visitRule(rule2);
-
-      const entry = env.get('ancestor');
-      expect(entry.kind).to.equal('Rule');
-      expect(entry.equations).to.have.lengthOf(2);
-    });
-  });
-
-  describe('Build Method (Integration)', () => {
-    it('should traverse the AST and build the complete environment', () => {
-      const nodes = [
-        makeFunc('add', 2),
-        makeFact('is_human'),
-        makeRule('is_mortal')
-      ];
-
-      const mockAST = {
-        [Symbol.iterator]: function* () { yield* nodes; }
-      } as any;
-
-      // mock of the accept method
-      nodes[0].accept = (v: any) => v.visitFunction(nodes[0]);
-      nodes[1].accept = (v: any) => v.visitFact(nodes[1]);
-      nodes[2].accept = (v: any) => v.visitRule(nodes[2]);
-
-      const resultingStack = visitor.build(mockAST);
-      const resultingEnv = resultingStack[0];
-
-      expect(resultingEnv.has('add')).to.be.true;
-      expect(resultingEnv.has('is_human')).to.be.true;
-      expect(resultingEnv.has('is_mortal')).to.be.true;
-    });
-  });
-});
+import { expect } from "chai";
+import {
+  Function as AstFunction,
+  Fact,
+  Rule,
+  SymbolPrimitive,
+  Equation,
+  EnvStack,
+  RuntimeFunction,
+  RuntimePredicate,
+  Function,
+  AST,
+} from "yukigo-ast";
+import { EnvBuilderVisitor } from "../../src/interpreter/components/EnvBuilder.js";
+import { RuntimeContext } from "../../src/interpreter/components/RuntimeContext.js";
+
+const id = (val: string) => ({ value: val }) as SymbolPrimitive;
+
+const makeEq = (arity: number): Equation =>
+  ({
+    patterns: new Array(arity).fill({ type: "MockPattern" }),
+    body: { type: "MockBody" } as any,
+  }) as any;
+
+const makeFunc = (
+  name: string,
+  arity: number,
+  eqCount: number = 1,
+): AstFunction => new Function(id(name), Array(eqCount).fill(makeEq(arity)));
+
+const makeFact = (name: string): Fact => {
+  const node = {
+    type: "Fact",
+    identifier: id(name),
+    patterns: [],
+  } as any;
+  node.accept = (v: any) => v.visitFact(node);
+  return node;
+};
+
+const makeRule = (name: string): Rule => {
+  const node = {
+    type: "Rule",
+    identifier: id(name),
+    patterns: [],
+    expressions: [],
+  } as any;
+  node.accept = (v: any) => v.visitRule(node);
+  return node;
+};
+
+describe("EnvBuilderVisitor", () => {
+  let ctx: RuntimeContext;
+  let visitor: EnvBuilderVisitor;
+  let env: EnvStack;
+
+  beforeEach(() => {
+    ctx = new RuntimeContext();
+    visitor = new EnvBuilderVisitor(ctx);
+    env = ctx.env;
+  });
+
+  describe("Function Declarations", () => {
+    it("should register a valid function", () => {
+      const funcNode = makeFunc("myFunc", 1);
+
+      visitor.visitFunction(funcNode);
+
+      expect(ctx.isDefined("myFunc")).to.be.true;
+      const entry = ctx.lookup("myFunc") as RuntimeFunction;
+
+      expect(entry).to.have.property("identifier", "myFunc");
+      expect(entry).to.have.property("arity", 1);
+      expect(entry.equations).to.have.lengthOf(1);
+    });
+
+    it("should register a function with multiple equations", () => {
+      const funcNode = makeFunc("fib", 1, 2);
+
+      visitor.visitFunction(funcNode);
+
+      const entry = ctx.lookup("fib") as RuntimeFunction;
+      expect(entry.equations).to.have.lengthOf(2);
+    });
+
+    it("should throw error if function has no equations", () => {
+      const funcNode = makeFunc("empty", 0, 0);
+
+      expect(() => visitor.visitFunction(funcNode)).to.throw(
+        /has no equations/,
+      );
+    });
+
+    it("should throw error if equations have different arity", () => {
+      const funcNode = makeFunc("badFunc", 1);
+      funcNode.equations.push(makeEq(2));
+
+      expect(() => visitor.visitFunction(funcNode)).to.throw(
+        /must have the same arity/,
+      );
+    });
+  });
+
+  describe("Logic Programming (Facts)", () => {
+    it("should register a new Fact", () => {
+      const factNode = makeFact("parent");
+
+      visitor.visitFact(factNode);
+
+      expect(ctx.isDefined("parent")).to.be.true;
+      const entry = ctx.lookup("parent") as RuntimePredicate;
+      expect(entry).to.have.property("kind", "Predicate");
+      expect(entry.equations).to.have.lengthOf(1);
+      expect(entry.equations[0]).to.equal(factNode);
+    });
+
+    it("should append to existing Fact if identifier exists", () => {
+      const f1 = makeFact("parent");
+      const f2 = makeFact("parent");
+
+      visitor.visitFact(f1);
+      visitor.visitFact(f2);
+
+      const entry = ctx.lookup("parent") as RuntimePredicate;
+      expect(entry.kind).to.equal("Predicate");
+      expect(entry.equations).to.have.lengthOf(2);
+      expect(entry.equations[0]).to.equal(f1);
+      expect(entry.equations[1]).to.equal(f2);
+    });
+
+    it("should overwrite existing entry if it is not a Fact", () => {
+      ctx.define("test", { type: "SomethingElse", equations: [] } as any);
+      const factNode = makeFact("test");
+      visitor.visitFact(factNode);
+
+      const entry = ctx.lookup("test") as RuntimePredicate;
+      expect(entry.kind).to.equal("Predicate");
+      expect(entry.equations).to.have.lengthOf(1);
+      expect(entry.equations[0]).to.equal(factNode);
+    });
+  });
+
+  describe("Logic Programming (Rules)", () => {
+    it("should register a new Rule", () => {
+      const ruleNode = makeRule("grandparent");
+
+      visitor.visitRule(ruleNode);
+
+      expect(ctx.isDefined("grandparent")).to.be.true;
+      const entry = ctx.lookup("grandparent") as RuntimePredicate;
+      expect(entry).to.have.property("kind", "Predicate");
+      expect(entry.equations).to.have.lengthOf(1);
+      expect(entry.equations[0]).to.equal(ruleNode);
+    });
+
+    it("should append to existing Rule group", () => {
+      const r1 = makeRule("ancestor");
+      const r2 = makeRule("ancestor");
+
+      visitor.visitRule(r1);
+      visitor.visitRule(r2);
+
+      const entry = ctx.lookup("ancestor") as RuntimePredicate;
+      expect(entry.kind).to.equal("Predicate");
+      expect(entry.equations).to.have.lengthOf(2);
+      expect(entry.equations[0]).to.equal(r1);
+      expect(entry.equations[1]).to.equal(r2);
+    });
+  });
+
+  it("should traverse the AST and build the complete environment", () => {
+    const nodes: AST = [
+      makeFunc("add", 2),
+      makeFact("is_human"),
+      makeRule("is_mortal"),
+    ];
+
+    visitor.build(nodes);
+    expect(ctx.isDefined("add")).to.be.true;
+    expect(ctx.isDefined("is_human")).to.be.true;
+    expect(ctx.isDefined("is_mortal")).to.be.true;
+  });
+});