Merge branch 'feature/java-module' of github.com:nanoapi-io/napi into feature/java-module

Author: LeBoufty

deno.lock

@@ -0,0 +1,117 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { getJavaFilesMap } from "../testFiles/index.ts";
+import {
+  BURGER,
+  CONDIMENT,
+  DOUBLEBURGER,
+  FOOD,
+  STEAK,
+} from "../testFiles/constants.ts";
+import { JavaPackageResolver } from "./index.ts";
+
+describe("Java Package Resolver", () => {
+  const files = getJavaFilesMap();
+  const condiment = files.get(CONDIMENT)!;
+  const food = files.get(FOOD)!;
+  const steak = files.get(STEAK)!;
+  const burger = files.get(BURGER)!;
+  const doubleburger = files.get(DOUBLEBURGER)!;
+  const packageResolver = new JavaPackageResolver();
+
+  test("parses Food.java", () => {
+    const result = packageResolver.resolveFile(food);
+    expect(result).toBeDefined();
+    expect(result.path).toStrictEqual(FOOD);
+    expect(result.package).toBe("io.nanoapi.testfiles.food");
+    expect(result.imports.length).toBe(0);
+    const symbol = result.symbol;
+    expect(symbol).toBeDefined();
+    expect(symbol.name).toBe("Food");
+    expect(symbol.type).toBe("interface");
+    expect(symbol.modifiers).toContain("public");
+    expect(symbol.modifiers.length).toBe(1);
+    expect(symbol.typeParamCount).toBe(0);
+    expect(symbol.superclass).toBeUndefined();
+    expect(symbol.interfaces.length).toBe(0);
+    expect(symbol.children.length).toBe(0);
+  });
+
+  test("parses Condiment.java", () => {
+    const result = packageResolver.resolveFile(condiment);
+    expect(result).toBeDefined();
+    expect(result.path).toStrictEqual(CONDIMENT);
+    expect(result.package).toBe("io.nanoapi.testfiles.food");
+    expect(result.imports.length).toBe(0);
+    const symbol = result.symbol;
+    expect(symbol).toBeDefined();
+    expect(symbol.name).toBe("Condiment");
+    expect(symbol.type).toBe("enum");
+    expect(symbol.modifiers).toContain("public");
+    expect(symbol.modifiers.length).toBe(1);
+    expect(symbol.typeParamCount).toBe(0);
+    expect(symbol.superclass).toBeUndefined();
+    expect(symbol.interfaces.length).toBe(0);
+    expect(symbol.children.length).toBe(0);
+  });
+
+  test("parses Steak.java", () => {
+    const result = packageResolver.resolveFile(steak);
+    expect(result).toBeDefined();
+    expect(result.path).toStrictEqual(STEAK);
+    expect(result.package).toBe("io.nanoapi.testfiles.food");
+    expect(result.imports.length).toBe(0);
+    const symbol = result.symbol;
+    expect(symbol).toBeDefined();
+    expect(symbol.name).toBe("Steak");
+    expect(symbol.type).toBe("class");
+    expect(symbol.modifiers).toContain("public");
+    expect(symbol.modifiers.length).toBe(1);
+    expect(symbol.typeParamCount).toBe(0);
+    expect(symbol.superclass).toBeUndefined();
+    expect(symbol.interfaces.length).toBe(1);
+    expect(symbol.interfaces[0]).toBe("Food");
+    expect(symbol.children.length).toBe(1);
+    const child = symbol.children[0];
+    expect(child).toBeDefined();
+    expect(child.name).toBe("Tapeworm");
+    expect(child.type).toBe("class");
+    expect(child.modifiers).toContain("private");
+    expect(child.modifiers).toContain("static");
+    expect(child.modifiers.length).toBe(2);
+    expect(child.typeParamCount).toBe(0);
+    expect(child.superclass).toBeUndefined();
+    expect(child.interfaces.length).toBe(0);
+    expect(child.children.length).toBe(0);
+  });
+
+  test("parses Burger.java", () => {
+    const result = packageResolver.resolveFile(burger);
+    expect(result).toBeDefined();
+    expect(result.path).toStrictEqual(BURGER);
+    expect(result.package).toBe("io.nanoapi.testfiles.food");
+    expect(result.imports.length).toBe(2);
+    const symbol = result.symbol;
+    expect(symbol).toBeDefined();
+    expect(symbol.name).toBe("Burger");
+    expect(symbol.type).toBe("class");
+    expect(symbol.typeParamCount).toBe(1);
+    expect(symbol.superclass).toBeUndefined();
+    expect(symbol.interfaces.length).toBe(1);
+  });
+
+  test("parses DoubleBurger.java", () => {
+    const result = packageResolver.resolveFile(doubleburger);
+    expect(result).toBeDefined();
+    expect(result.path).toStrictEqual(DOUBLEBURGER);
+    expect(result.package).toBe("io.nanoapi.testfiles.food");
+    const symbol = result.symbol;
+    expect(symbol).toBeDefined();
+    expect(symbol.name).toBe("DoubleBurger");
+    expect(symbol.type).toBe("class");
+    expect(symbol.typeParamCount).toBe(2);
+    expect(symbol.superclass).toBeDefined();
+    expect(symbol.superclass).toBe("Burger");
+    expect(symbol.interfaces.length).toBe(0);
+  });
+});

packages/cli/src/languagePlugins/java/packageResolver/index.test.ts

@@ -0,0 +1,100 @@
+import type Parser from "tree-sitter";
+import type {
+  ExportedSymbol,
+  JavaFile,
+  Modifier,
+  SymbolType,
+} from "./types.ts";
+import { JAVA_PROGRAM_QUERY } from "./queries.ts";
+import { javaParser } from "../../../helpers/treeSitter/parsers.ts";
+
+export class JavaPackageResolver {
+  parser: Parser = javaParser;
+
+  resolveFile(file: {
+    path: string;
+    rootNode: Parser.SyntaxNode;
+  }): JavaFile {
+    const captures = JAVA_PROGRAM_QUERY.captures(file.rootNode);
+    const packagename = captures.find((c) => c.name === "package")?.node.text ??
+      "";
+    const imports = captures.filter((c) => c.name === "import").map((c) =>
+      c.node.text
+    );
+    const declaration = captures.find((c) =>
+      !["package", "import"].includes(c.name)
+    );
+    if (!declaration) {
+      throw Error(`No declaration found for ${file.path}`);
+    }
+    const symbol = this.#processDeclaration(
+      declaration.node,
+      declaration.name as SymbolType,
+    );
+    return {
+      path: file.path,
+      rootNode: file.rootNode,
+      symbol,
+      package: packagename,
+      imports,
+    };
+  }
+
+  #processDeclaration(
+    node: Parser.SyntaxNode,
+    type: SymbolType,
+  ): ExportedSymbol {
+    const modifiersNode = node.children.find((c) => c.type === "modifiers");
+    const modifiers: Modifier[] = [];
+    if (modifiersNode) {
+      modifiers.push(...modifiersNode.children.map((c) => c.text as Modifier));
+    }
+    const idNode = node.childForFieldName("name")!;
+    const name = idNode.text;
+    const typeParams = node.childForFieldName("type_parameters");
+    let typeParamCount = 0;
+    if (typeParams) {
+      typeParamCount = typeParams.namedChildren.length;
+    }
+    let superclass: string | undefined = undefined;
+    const superclassNode = node.childForFieldName("superclass");
+    if (superclassNode) {
+      superclass = superclassNode.namedChildren[0].text;
+    }
+    const interfacesNode = node.childForFieldName("interfaces");
+    const interfaces: string[] = [];
+    if (interfacesNode) {
+      interfaces.push(
+        ...interfacesNode.namedChildren[0].namedChildren.map((c) => c.text),
+      );
+    }
+    const children: ExportedSymbol[] = [];
+    const bodyNode = node.childForFieldName("body");
+    if (bodyNode) {
+      children.push(
+        ...bodyNode.children.filter((c) =>
+          [
+            "class_declaration",
+            "interface_declaration",
+            "enum_declaration",
+            "record_declaration",
+            "annotation_type_declaration",
+          ].includes(c.type)
+        ).map((c) =>
+          this.#processDeclaration(c, c.type.split("_")[0] as SymbolType)
+        ),
+      );
+    }
+    return {
+      name,
+      type,
+      modifiers,
+      typeParamCount,
+      superclass,
+      interfaces,
+      children,
+      node,
+      idNode,
+    };
+  }
+}

packages/cli/src/languagePlugins/java/packageResolver/index.ts

@@ -0,0 +1,15 @@
+import Parser from "npm:tree-sitter";
+import { javaParser } from "../../../helpers/treeSitter/parsers.ts";
+
+export const JAVA_PROGRAM_QUERY = new Parser.Query(
+  javaParser.getLanguage(),
+  `(program [
+  (package_declaration (_) @package)
+  (import_declaration (_) @import)
+  (class_declaration) @class
+  (interface_declaration) @interface
+  (enum_declaration) @enum
+  (record_declaration) @record
+  (annotation_type_declaration) @annotation
+  ])`,
+);

packages/cli/src/languagePlugins/java/packageResolver/queries.ts

@@ -0,0 +1,55 @@
+import type Parser from "tree-sitter";
+
+export const JAVA_PUBLIC_MODIFIER = "public";
+export const JAVA_PRIVATE_MODIFIER = "private";
+export const JAVA_PROTECTED_MODIFIER = "protected";
+export const JAVA_ABSTRACT_MODIFIER = "abstract";
+export const JAVA_FINAL_MODIFIER = "final";
+export const JAVA_STATIC_MODIFIER = "static";
+export const JAVA_STRICTFP_MODIFIER = "strictfp";
+export const JAVA_SEALED_MODIFIER = "sealed";
+export const JAVA_NONSEALED_MODIFIER = "non-sealed";
+
+export type Modifier =
+  | typeof JAVA_PUBLIC_MODIFIER
+  | typeof JAVA_PRIVATE_MODIFIER
+  | typeof JAVA_PROTECTED_MODIFIER
+  | typeof JAVA_ABSTRACT_MODIFIER
+  | typeof JAVA_FINAL_MODIFIER
+  | typeof JAVA_STATIC_MODIFIER
+  | typeof JAVA_STRICTFP_MODIFIER
+  | typeof JAVA_SEALED_MODIFIER
+  | typeof JAVA_NONSEALED_MODIFIER;
+
+export const JAVA_CLASS_TYPE = "class";
+export const JAVA_INTERFACE_TYPE = "interface";
+export const JAVA_ENUM_TYPE = "enum";
+export const JAVA_RECORD_TYPE = "record";
+export const JAVA_ANNOTATION_TYPE = "annotation";
+
+export type SymbolType =
+  | typeof JAVA_CLASS_TYPE
+  | typeof JAVA_INTERFACE_TYPE
+  | typeof JAVA_ENUM_TYPE
+  | typeof JAVA_RECORD_TYPE
+  | typeof JAVA_ANNOTATION_TYPE;
+
+export interface JavaFile {
+  path: string;
+  rootNode: Parser.SyntaxNode;
+  symbol: ExportedSymbol;
+  package: string;
+  imports: string[];
+}
+
+export interface ExportedSymbol {
+  name: string;
+  type: SymbolType;
+  modifiers: Modifier[];
+  typeParamCount: number;
+  superclass?: string;
+  interfaces: string[];
+  children: ExportedSymbol[];
+  node: Parser.SyntaxNode;
+  idNode: Parser.SyntaxNode;
+}

packages/cli/src/languagePlugins/java/packageResolver/types.ts

@@ -0,0 +1,12 @@
+import { javaFilesFolder } from "./index.ts";
+import { join } from "@std/path";
+
+// Root
+export const APP = join(javaFilesFolder, "App.java");
+
+// Food package
+export const CONDIMENT = join(javaFilesFolder, "food/Condiment.java");
+export const FOOD = join(javaFilesFolder, "food/Food.java");
+export const STEAK = join(javaFilesFolder, "food/Steak.java");
+export const BURGER = join(javaFilesFolder, "food/Burger.java");
+export const DOUBLEBURGER = join(javaFilesFolder, "food/DoubleBurger.java");

packages/cli/src/languagePlugins/java/testFiles/constants.ts

@@ -9,7 +9,10 @@ import {
 if (!import.meta.dirname) {
   throw new Error("import.meta.dirname is not defined");
 }
-export const javaFilesFolder = join(import.meta.dirname, "napi-tests");
+export const javaFilesFolder = join(
+  import.meta.dirname,
+  "napi-tests/src/main/java/io/nanoapi/testfiles",
+);
 const javaFilesMap = new Map<
   string,
   { path: string; rootNode: Parser.SyntaxNode }

packages/cli/src/languagePlugins/java/testFiles/index.ts

@@ -0,0 +1,29 @@
+package io.nanoapi.testfiles.food;
+
+import java.io;
+import java.lang.System;
+
+public class Burger<T> implements Food {
+
+    public void eat() {
+        System.out.println("Yummy !");
+    }
+
+    public double getPrice() {
+        T t = new T();
+        if (t instanceof Food) {
+            return t.getPrice() + 2.0;
+        } else {
+            return 2.0;
+        }
+    }
+
+    public double getCalories() {
+        T t = new T();
+        if (t instanceof Food) {
+            return t.getCalories + 50.0;
+        } else {
+            return 50.0;
+        }
+    }
+}

packages/cli/src/languagePlugins/java/testFiles/napi-tests/src/main/java/io/nanoapi/testfiles/food/Burger.java

@@ -0,0 +1,7 @@
+package io.nanoapi.testfiles.food;
+
+public enum Condiment {
+    SALAD,
+    TOMATO,
+    ONION,
+}

packages/cli/src/languagePlugins/java/testFiles/napi-tests/src/main/java/io/nanoapi/testfiles/food/Condiment.java

@@ -0,0 +1,3 @@
+package io.nanoapi.testfiles.food;
+
+public class DoubleBurger<T, N> extends Burger {}