Extractor (#158)

Author: LeBoufty

src/languagePlugins/java/extractor/index.test.ts

@@ -0,0 +1,22 @@
+import { describe, test } from "@std/testing/bdd";
+import { expect } from "@std/expect";
+import { getJavaFilesContentMap } from "../testFiles/index.ts";
+import { generateJavaDependencyManifest } from "../../../manifest/dependencyManifest/java/index.ts";
+import { JavaExtractor } from "./index.ts";
+import { WORMKILLER } from "../testFiles/constants.ts";
+
+describe("Java extractor", () => {
+  const files = getJavaFilesContentMap();
+  const manifest = generateJavaDependencyManifest(files);
+  const extractor = new JavaExtractor(files, manifest);
+  test("extracts wormkiller", () => {
+    const symbolsMap: Map<string, { filePath: string; symbols: Set<string> }> =
+      new Map();
+    symbolsMap.set(WORMKILLER, {
+      filePath: WORMKILLER,
+      symbols: new Set("Wormkiller"),
+    });
+    const extracted = extractor.extractSymbols(symbolsMap);
+    expect(extracted.size).toBe(4);
+  });
+});

src/languagePlugins/java/extractor/index.ts

@@ -0,0 +1,64 @@
+import type Parser from "tree-sitter";
+import type { DependencyManifest } from "../../../manifest/dependencyManifest/types.ts";
+import { JavaInvocationResolver } from "../invocationResolver/index.ts";
+import { javaParser } from "../../../helpers/treeSitter/parsers.ts";
+import { JavaPackageMapper } from "../packageMapper/index.ts";
+import { JavaImportResolver } from "../importResolver/index.ts";
+import { ExportedFile } from "./types.ts";
+
+export class JavaExtractor {
+  manifest: DependencyManifest;
+  resolver: JavaInvocationResolver;
+  constructor(
+    files: Map<string, { path: string; content: string }>,
+    manifest: DependencyManifest,
+  ) {
+    this.manifest = manifest;
+    const parsedFiles = new Map<
+      string,
+      { path: string; rootNode: Parser.SyntaxNode }
+    >();
+    for (const [filepath, file] of files) {
+      parsedFiles.set(filepath, {
+        path: file.path,
+        rootNode: javaParser.parse(file.content).rootNode,
+      });
+    }
+    const mapper = new JavaPackageMapper(parsedFiles);
+    const importresolver = new JavaImportResolver(mapper);
+    this.resolver = new JavaInvocationResolver(importresolver);
+  }
+
+  extractSymbols(
+    symbolsMap: Map<
+      string,
+      {
+        filePath: string;
+        symbols: Set<string>;
+      }
+    >,
+  ): Map<string, { path: string; content: string }> {
+    const exportedfiles = Array.from(
+      symbolsMap.keys().map((k) => new ExportedFile(k, this.resolver)),
+    );
+    const filesToKeep: Map<string, { path: string; content: string }> =
+      new Map();
+    for (const f of exportedfiles) {
+      if (!filesToKeep.has(f.file.path)) {
+        filesToKeep.set(f.file.path, {
+          path: f.file.path,
+          content: f.file.rootNode.text,
+        });
+      }
+      for (const [k, v] of f.dependencies) {
+        if (!filesToKeep.has(k)) {
+          filesToKeep.set(k, {
+            path: v.path,
+            content: v.rootNode.text,
+          });
+        }
+      }
+    }
+    return filesToKeep;
+  }
+}

src/languagePlugins/java/extractor/types.ts

@@ -0,0 +1,21 @@
+import type { JavaInvocationResolver } from "../invocationResolver/index.ts";
+import type { JavaFile } from "../packageResolver/types.ts";
+
+export class ExportedFile {
+  dependencies: Map<string, JavaFile>;
+  file: JavaFile;
+  constructor(filepath: string, resolver: JavaInvocationResolver) {
+    this.file = resolver.mapper.files.get(filepath)!;
+    this.dependencies = new Map();
+    const stack = [this.file];
+    while (stack.length > 0) {
+      const current = stack.pop()!;
+      if (this.dependencies.has(current.path)) {
+        continue;
+      }
+      this.dependencies.set(current.path, current);
+      const currentDep = resolver.getInvocations(current).resolved;
+      stack.push(...currentDep.values().map((v) => v.file));
+    }
+  }
+}