yukigo 0.1.0 → 0.1.1

package/.mocharc.json

@@ -1,4 +1,4 @@
-{
-  "extension": ["ts"],
-  "spec": "tests/**/*.spec.ts"
+{
+  "extension": ["ts"],
+  "spec": "tests/**/*.spec.ts"
 }

package/README.md

@@ -1,199 +1,193 @@
-# ❄️ Yukigo (WIP)
-A universal, multi-language, multi-paradigm code analyzer highly inspired in [mulang](https://github.com/mumuki/mulang)
-
-> [!WARNING]
-> This project is still in a "work in progress" state. Everything is subject to change :)
-
-
-## Components
-
-### **Abstract Semantic Tree:**
-
-This is the intermediate representation of any language. Allows us to analyse the semantics of the code independently of the paradigm or the language.
-
-### **Inspector:**
-
-We provide a set of built-in expectations for analysing code. Also allows to define custom expectations at runtime.
-
-### **Translator:**
-
-Translation AST-to-Typescript, this allows us to have an equivalent code to run input-output tests everywhere.
-
-### **Tester:**
-
-Runs tests for the Typescript translated code on an isolated enviroment.
-
-# Usage
-
-## Installation
-
-We will be using Haskell as the target language in this example.
-
-```
-npm install yukigo yukigo-haskell-parser
-```
-
-or
-
-```
-yarn add yukigo yukigo-haskell-parser
-```
-
-## Example
-
-```ts
-import { ASTAnalyzer } from "yukigo";
-import { YukigoHaskellParser } from "yukigo-haskell-parser";
-
-const code = "doble num = num * 2";
-const expectations = [
-  {
-    inspection: "HasBinding",
-    args: { name: "minimoEntre" },
-    expected: false,
-  },
-  {
-    inspection: "HasBinding",
-    args: { name: "doble" },
-    expected: true,
-  },
-];
-
-const parser = new YukigoHaskellParser();
-const ast = parser.parse(code);
-
-const analyser = new ASTAnalyzer(ast);
-const result = analyser.analyse(expectations);
-
-console.log(results);
-// [
-//   {
-//     rule: {
-//       inspection: "HasBinding",
-//       args: { name: "minimoEntre" },
-//       expected: false,
-//     },
-//     passed: true,
-//     actual: false,
-//   },
-//   {
-//     rule: {
-//       inspection: "HasBinding",
-//       args: { name: "doble" },
-//       expected: true,
-//     },
-//     passed: true,
-//     actual: true,
-//   },
-// ];
-```
-
-## Example with Mulang's Inspections (in a YAML file)
-
-```ts
-import { ASTAnalyzer, translateMulangToInspectionRules } from "yukigo";
-import { YukigoHaskellParser } from "yukigo-haskell-parser";
-
-const code = `
-squareList :: [Int] -> [Int]
-squareList xs = map (\n -> n * n) xs
-
-square :: Int -> Int
-square n = n * n
-
-squareList2 :: [Int] -> [Int]
-squareList2 = map square
-`;
-
-// Assuming the expectations are in a yaml file. Implement a way to load the actual file.
-const mulangInspections = `
-expectations:
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList
-  inspection: HasBinding
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList
-  inspection: HasLambdaExpression
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: square
-  inspection: HasArithmetic
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: doble
-  inspection: Not:HasBinding
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: square
-  inspection: Uses:n
-- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
-  binding: squareList2
-  inspection: Uses:map
-`;
-
-const expectations = translateMulangToInspectionRules(mulangInspections);
-
-const parser = new YukigoHaskellParser();
-const ast = parser.parse(code);
-
-const analyser = new ASTAnalyzer(ast);
-const result = analyser.analyse(expectations);
-
-console.log(results);
-// [
-//   {
-//     rule: { inspection: "HasBinding", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: {
-//       inspection: "HasLambdaExpression",
-//       args: [Object],
-//       expected: true,
-//     },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "HasArithmetic", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "HasBinding", args: [Object], expected: false },
-//     passed: true,
-//     actual: false,
-//   },
-//   {
-//     rule: { inspection: "Uses", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-//   {
-//     rule: { inspection: "Uses", args: [Object], expected: true },
-//     passed: true,
-//     actual: true,
-//   },
-// ];
-```
-
-# Relevant tools
-- yukigo-ast: A library of AST's node definitions
-  
-## Tools
-- [CLI](https://github.com/noiseArch/yukigo-cli)
-  
-## Parsers
-- Haskell
-- Prolog
-
-# How to make a parser
-
-A yukigo's parser is a class that implements the interface `YukigoParser` which exposes a public method called `parse` and an `errors` array like this:
-```ts
-errors: string[];
-parse: (code: string) => AST;
-```
-
-The package `yukigo-ast` has all the current supported AST nodes.
-For the grammar, you can use a tool like Jison or Nearley.
-
-Here's a tutorial for implementing a small custom language.
+# ❄️ Yukigo
+A universal, multi-language, multi-paradigm code analyzer highly inspired in [mulang](https://github.com/mumuki/mulang)
+
+## Components
+
+### **Abstract Semantic Tree:**
+
+This is the intermediate representation of any language. Allows us to analyse the semantics of the code independently of the paradigm or the language.
+
+### **Analyzer:**
+
+The Analyzer is the component that traverses the AST and runs the specified inspections.
+
+### **Interpreter:**
+
+The Interpreter is the component that evaluates provided Expression nodes and returns the resultant PrimitiveValue 
+
+# Usage
+
+## Installation
+
+We will be using Haskell as the target language in this example.
+
+```
+npm install yukigo yukigo-haskell-parser
+```
+
+or
+
+```
+yarn add yukigo yukigo-haskell-parser
+```
+
+## Example
+
+```ts
+import { Analyzer } from "yukigo";
+import { YukigoHaskellParser } from "yukigo-haskell-parser";
+
+const code = "doble num = num * 2";
+const expectations = [
+  {
+    inspection: "HasBinding",
+    args: { name: "minimoEntre" },
+    expected: false,
+  },
+  {
+    inspection: "HasBinding",
+    args: { name: "doble" },
+    expected: true,
+  },
+];
+
+const parser = new YukigoHaskellParser();
+const ast = parser.parse(code);
+
+const analyzer = new ASTAnalyzer(ast);
+const result = analyzer.analyse(expectations);
+
+console.log(results);
+// [
+//   {
+//     rule: {
+//       inspection: "HasBinding",
+//       args: { name: "minimoEntre" },
+//       expected: false,
+//     },
+//     passed: true,
+//     actual: false,
+//   },
+//   {
+//     rule: {
+//       inspection: "HasBinding",
+//       args: { name: "doble" },
+//       expected: true,
+//     },
+//     passed: true,
+//     actual: true,
+//   },
+// ];
+```
+
+## Example with Mulang's Inspections (in a YAML file)
+
+```ts
+import { Analyzer, translateMulangToInspectionRules } from "yukigo";
+import { YukigoHaskellParser } from "yukigo-haskell-parser";
+
+const code = `
+squareList :: [Int] -> [Int]
+squareList xs = map (\n -> n * n) xs
+
+square :: Int -> Int
+square n = n * n
+
+squareList2 :: [Int] -> [Int]
+squareList2 = map square
+`;
+
+// Assuming the expectations are in a yaml file. Implement a way to load the actual file.
+const mulangInspections = `
+expectations:
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList
+  inspection: HasBinding
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList
+  inspection: HasLambdaExpression
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: square
+  inspection: HasArithmetic
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: doble
+  inspection: Not:HasBinding
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: square
+  inspection: Uses:n
+- !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+  binding: squareList2
+  inspection: Uses:map
+`;
+
+const expectations = translateMulangToInspectionRules(mulangInspections);
+
+const parser = new YukigoHaskellParser();
+const ast = parser.parse(code);
+
+const analyzer = new Analyzer(ast);
+const result = analyzer.analyse(expectations);
+
+console.log(results);
+// [
+//   {
+//     rule: { inspection: "HasBinding", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: {
+//       inspection: "HasLambdaExpression",
+//       args: [Object],
+//       expected: true,
+//     },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "HasArithmetic", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "HasBinding", args: [Object], expected: false },
+//     passed: true,
+//     actual: false,
+//   },
+//   {
+//     rule: { inspection: "Uses", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+//   {
+//     rule: { inspection: "Uses", args: [Object], expected: true },
+//     passed: true,
+//     actual: true,
+//   },
+// ];
+```
+
+# Relevant tools
+- yukigo-ast: A library of AST node definitions and utilities for making yukigo parsers
+  
+## Tools
+- [CLI](https://github.com/noiseArch/yukigo-cli)
+- create-yukigo-parser: A scaffolding tool to quickstart a yukigo parser with recommended configuration
+
+## Parsers
+- Haskell
+- Prolog
+- Wollok
+
+# How to make a parser
+
+A yukigo's parser is a class that implements the interface `YukigoParser` which exposes a public method called `parse` and an `errors` array like this:
+```ts
+errors: string[];
+parse: (code: string) => AST;
+```
+
+The package `yukigo-ast` has all the current supported AST nodes.
+For the grammar, you can use a tool like Jison or Nearley.
+
+Here's a [tutorial](https://miyukiproject.github.io/yukigo/guides/making-a-parser.html) for implementing a small custom language.

package/dist/analyzer/GraphBuilder.d.ts

@@ -0,0 +1,29 @@
+import { Application, AST, ASTNode, Call, Class, Fact, Function, Interface, Method, New, Object as YuObject, Procedure, Rule, 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 declare class GraphBuilder extends TraverseVisitor {
+    private defs;
+    private calls;
+    private scope;
+    build(ast: AST): SymbolGraph;
+    private addDefinition;
+    visitFunction(node: Function): void;
+    visitMethod(node: Method): void;
+    visitProcedure(node: Procedure): void;
+    visitRule(node: Rule): void;
+    visitFact(node: Fact): void;
+    visitClass(node: Class): void;
+    visitObject(node: YuObject): void;
+    visitInterface(node: Interface): void;
+    visitTypeAlias(node: TypeAlias): void;
+    visitTypeSignature(node: TypeSignature): void;
+    visitCall(node: Call): void;
+    visitApplication(node: Application): void;
+    visitNew(node: New): void;
+    visitExist(node: Exist): void;
+}
+export {};

package/dist/analyzer/GraphBuilder.js

@@ -0,0 +1,99 @@
+import { SymbolPrimitive, TraverseVisitor, } from "yukigo-ast";
+export class GraphBuilder extends TraverseVisitor {
+    defs = new Map();
+    calls = new Map();
+    scope = "";
+    build(ast) {
+        ast.forEach((node) => node.accept(this));
+        return { defs: this.defs, calls: this.calls };
+    }
+    addDefinition(name, node) {
+        const existing = this.defs.get(name) || [];
+        this.defs.set(name, [...existing, node]);
+    }
+    visitFunction(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitMethod(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitProcedure(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitRule(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.equations);
+        this.scope = "";
+    }
+    visitFact(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.traverseCollection(node.patterns);
+        this.scope = "";
+    }
+    visitClass(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitObject(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitInterface(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        node.expression.accept(this);
+        this.scope = "";
+    }
+    visitTypeAlias(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.scope = "";
+    }
+    visitTypeSignature(node) {
+        this.scope = node.identifier.value;
+        this.addDefinition(this.scope, node);
+        this.scope = "";
+    }
+    visitCall(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.callee.value, ...arr]);
+    }
+    visitApplication(node) {
+        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) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.identifier.value, ...arr]);
+    }
+    visitExist(node) {
+        if (!this.scope)
+            return;
+        const arr = this.calls.get(this.scope) || [];
+        this.calls.set(this.scope, [node.identifier.value, ...arr]);
+    }
+}

package/dist/analyzer/index.d.ts

@@ -1,5 +1,5 @@
-import { AST } from "@yukigo/ast";
-import { InspectionHandler, InspectionMap } from "./utils.js";
+import { AST } from "yukigo-ast";
+import { InspectionMap, VisitorConstructor } from "./utils.js";
 export type AnalysisResult = {
     rule: InspectionRule;
     passed: boolean;
@@ -12,11 +12,12 @@ export type InspectionRule = {
     args: string[];
     expected: boolean;
 };
-export declare const defaultInspectionSet: InspectionMap;
+export declare const DefaultInspectionSet: InspectionMap;
+export declare const DefaultSmellsSet: InspectionMap;
 /**
  * The Analyzer class.
  * @remarks
- * The Analyzer is the part of Yukigo which runs the inspections on the AST.
+ * The Analyzer is the part of Yukigo which runs the inspections on the AST.s
  */
 export declare class Analyzer {
     /**
@@ -24,27 +25,15 @@ export declare class Analyzer {
      * You can load your set of inspections or leave the default one.
      * @defaultValue a default set of inspections for each supported paradigm
      */
-    private inspectionHandlers;
-    constructor(inspectionSet?: InspectionMap);
+    private inspectionConstructors;
+    private smellsConstructors;
+    constructor(inspectionSet?: InspectionMap, smellsSet?: InspectionMap);
     /**
      * Registers a new custom inspection handler after Analyzer was instantiated.
      * @param name The name of the inspection (e.g., "HasArithmetic").
-     * @param handler The function that implements the inspection logic.
-     *
-     * @example
-     * // Implementation of HasArithmetic inspection
-     * export class UsesArithmetic extends TraverseVisitor {
-     *  visitArithmeticBinaryOperation(node: ArithmeticBinaryOperation): void {
-     *    throw new StopTraversalException();
-     *  }
-     *  visitArithmeticUnaryOperation(node: ArithmeticUnaryOperation): void {
-     *    throw new StopTraversalException();
-     *  }
-     * }
-     * const analyzer = new ASTAnalyzer(ast);
-     * analyzer.registerInspection("HasArithmetic", (node, args) => executeVisitor(node, new UsesArithmetic()));
+     * @param visitorConstructor The constructor for the TraverseVisitor class.
      */
-    registerInspection(name: string, handler: InspectionHandler): void;
+    registerInspection(name: string, visitorConstructor: VisitorConstructor): void;
     /**
      * Runs a list of inspection rules against the AST.
      * @param ast The parsed AST.
@@ -67,5 +56,4 @@ export declare class Analyzer {
      * const analysisResults = analyzer.analyze(expectations);
      */
     analyze(ast: AST, rules: InspectionRule[]): AnalysisResult[];
-    private runRule;
 }