Pass project dependencies to isolated delombok process

Author: h4xr

src/main/java/com/neuvem/java2graph/passes/DelombokPass.java

@@ -5,40 +5,46 @@
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
+import java.io.File;
 import java.io.InputStreamReader;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
+import java.util.*;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
 public class DelombokPass implements Pass {
 
+    private static final Pattern PACKAGE_PATTERN = Pattern.compile("^\\s*package\\s+([\\w.]+)\\s*;");
+
     @Override
     public void execute(Java2GraphConfig config, GraphContext context) throws Exception {
         if (!config.isEnableLombok()) {
             return;
         }
 
-        System.out.println("Processing Lombok annotations via isolated process (filtering builds/hidden)...");
+        System.out.println("Processing Lombok annotations via isolated process (with classpath resolution)...");
 
         Path delombokDir = Files.createTempDirectory("delombok");
         String javaHome = System.getProperty("java.home");
         String javaBin = javaHome + "/bin/java";
-        String classpath = System.getProperty("java.class.path");
+        String mainClasspath = System.getProperty("java.class.path");
+
+        // Resolve the project's dependencies for delombok attribution
+        String projectClasspath = resolveProjectClasspath(config.getJarPaths());
 
-        // Identify source directories while excluding build/hidden folders
-        List<String> srcPaths = findSourceDirs(config.getSrcDir());
-        if (srcPaths.isEmpty()) {
+        // Identify unique source roots (package roots) to preserve structure while avoiding build artifacts
+        Set<String> srcRoots = findSourceRoots(config.getSrcDir());
+        if (srcRoots.isEmpty()) {
             System.out.println("No Java source files found in " + config.getSrcDir());
             return;
         }
 
-        // Use a response file for delombok to avoid command-line length limits and manage inputs
+        // Use a response file for delombok to avoid command-line length limits
         Path argFile = Files.createTempFile("delombok_args", ".args");
         try (BufferedWriter writer = Files.newBufferedWriter(argFile)) {
-            for (String path : srcPaths) {
+            for (String path : srcRoots) {
                 writer.write("\"" + path.replace("\\", "\\\\") + "\"");
                 writer.newLine();
             }
@@ -62,11 +68,17 @@ public void execute(Java2GraphConfig config, GraphContext context) throws Except
         command.add("--add-opens=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED");
 
         command.add("-cp");
-        command.add(classpath);
+        command.add(mainClasspath);
         command.add("lombok.launch.Main");
         command.add("delombok");
         command.add("--nocopy");
         command.add("--quiet");
+
+        if (!projectClasspath.isEmpty()) {
+            command.add("--classpath");
+            command.add(projectClasspath);
+        }
+
         command.add("@" + argFile.toAbsolutePath());
         command.add("-d");
         command.add(delombokDir.toAbsolutePath().toString());
@@ -79,14 +91,13 @@ public void execute(Java2GraphConfig config, GraphContext context) throws Except
         try (BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
             String line;
             while ((line = reader.readLine()) != null) {
-                // Suppress verbose hidden directory messages from Lombok
                 if (line.contains("hidden directory")) continue;
                 output.append(line).append("\n");
             }
         }
 
         int exitCode = process.waitFor();
-        Files.deleteIfExists(argFile); // Clean up the temp args file
+        Files.deleteIfExists(argFile);
 
         if (exitCode != 0) {
             System.err.println("Delombok failed with exit code " + exitCode);
@@ -96,20 +107,74 @@ public void execute(Java2GraphConfig config, GraphContext context) throws Except
             throw new RuntimeException("Delombok process failed. See logs for details.");
         }
 
-        // Update the src directory for subsequent passes
+        // IMPORTANT: Update the src directory for subsequent passes
         config.setSrcDir(delombokDir);
 
         System.out.println("Lombok processing complete. Delomboked to: " + delombokDir);
     }
 
-    private List<String> findSourceDirs(Path root) throws Exception {
-        try (Stream<Path> walk = Files.walk(root)) {
-            return walk.filter(Files::isDirectory)
-                    .filter(path -> !isExcluded(path))
-                    .filter(this::hasJavaFiles)
-                    .map(path -> path.toAbsolutePath().toString())
-                    .collect(Collectors.toList());
+    private String resolveProjectClasspath(List<Path> jarPaths) {
+        if (jarPaths == null || jarPaths.isEmpty()) {
+            return "";
+        }
+        List<String> classpathElements = new ArrayList<>();
+        for (Path path : jarPaths) {
+            if (Files.isRegularFile(path) && path.toString().endsWith(".jar")) {
+                classpathElements.add(path.toAbsolutePath().toString());
+            } else if (Files.isDirectory(path)) {
+                try (Stream<Path> walk = Files.walk(path)) {
+                    walk.filter(p -> Files.isRegularFile(p) && p.toString().endsWith(".jar"))
+                        .map(p -> p.toAbsolutePath().toString())
+                        .forEach(classpathElements::add);
+                } catch (Exception e) {
+                    // Ignore and continue
+                }
+            }
+        }
+        return String.join(File.pathSeparator, classpathElements);
+    }
+
+    private Set<String> findSourceRoots(Path start) throws Exception {
+        Set<String> roots = new LinkedHashSet<>();
+        try (Stream<Path> walk = Files.walk(start)) {
+            walk.filter(path -> path.toString().endsWith(".java"))
+                .filter(file -> !isExcluded(file))
+                .forEach(file -> {
+                    // Check if already covered
+                    if (roots.stream().anyMatch(root -> file.startsWith(Path.of(root)))) {
+                        return;
+                    }
+                    String root = discoverRoot(file);
+                    if (root != null) {
+                        roots.add(root);
+                    }
+                });
         }
+        return roots;
+    }
+
+    private String discoverRoot(Path file) {
+        try (BufferedReader reader = Files.newBufferedReader(file)) {
+            String line;
+            int count = 0;
+            while ((line = reader.readLine()) != null && count < 100) {
+                Matcher m = PACKAGE_PATTERN.matcher(line);
+                if (m.find()) {
+                    String pkg = m.group(1);
+                    int depth = pkg.split("\\.").length;
+                    Path root = file.getParent();
+                    for (int i = 0; i < depth; i++) {
+                        if (root.getParent() != null) root = root.getParent();
+                    }
+                    return root.toAbsolutePath().toString();
+                }
+                count++;
+            }
+        } catch (Exception e) {
+            // Log quietly and ignore
+        }
+        // If no package, root is parent
+        return file.getParent().toAbsolutePath().toString();
     }
 
     private boolean isExcluded(Path path) {
@@ -126,12 +191,4 @@ private boolean isExcluded(Path path) {
         }
         return false;
     }
-
-    private boolean hasJavaFiles(Path dir) {
-        try (Stream<Path> files = Files.list(dir)) {
-            return files.anyMatch(p -> p.getFileName().toString().endsWith(".java"));
-        } catch (Exception e) {
-            return false;
-        }
-    }
 }