added opening notebook in context of project

Author: Achal1607

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/JshellStreamsHandler.java

@@ -15,7 +15,6 @@
  */
 package org.netbeans.modules.nbcode.java.notebook;
 
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PrintStream;

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/NotebookCommandsHandler.java

@@ -34,7 +34,8 @@ public class NotebookCommandsHandler implements CommandProvider {
     private static final String NBLS_JSHELL_EXEC = "nbls.jshell.execute.cell";
     private static final String NBLS_JSHELL_INTERRUPT = "nbls.jshell.interrupt.cell";
     private static final String NBLS_OPEN_PROJECT_JSHELL = "nbls.jshell.project.open";
-    private static final Set<String> COMMANDS = new HashSet<>(Arrays.asList(NBLS_JSHELL_EXEC, NBLS_OPEN_PROJECT_JSHELL, NBLS_JSHELL_INTERRUPT));
+    private static final String NBLS_NOTEBOOK_PROJECT_MAPPING = "nbls.notebook.project.context";
+    private static final Set<String> COMMANDS = new HashSet<>(Arrays.asList(NBLS_JSHELL_EXEC, NBLS_OPEN_PROJECT_JSHELL, NBLS_JSHELL_INTERRUPT, NBLS_NOTEBOOK_PROJECT_MAPPING));
 
     @Override
     public Set<String> getCommands() {
@@ -52,6 +53,8 @@ public CompletableFuture<Object> runCommand(String command, List<Object> argumen
                     return CompletableFuture.completedFuture(CodeEval.getInstance().interrupt(arguments));
                 case NBLS_OPEN_PROJECT_JSHELL:
                     return CommandHandler.openJshellInProjectContext(arguments).thenApply(list -> (Object) list);
+                case NBLS_NOTEBOOK_PROJECT_MAPPING:
+                    return CommandHandler.getNotebookProjectMappingPath(arguments).thenApply(prj -> (Object) prj);
                 default:
                     return CompletableFuture.failedFuture(new UnsupportedOperationException("Command not supported: " + command));
             }

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/NotebookConfigs.java

@@ -33,11 +33,17 @@
  */
 public class NotebookConfigs {
 
-    private static final String[] NOTEBOOK_CONFIG_LABELS = {"notebook.classpath", "notebook.modulepath", "notebook.addmodules", "notebook.enablePreview", "notebook.implicitImports"};
+    private static final String[] NOTEBOOK_CONFIG_LABELS = {"notebook.classpath",
+        "notebook.modulepath",
+        "notebook.addmodules",
+        "notebook.enablePreview",
+        "notebook.implicitImports",
+        "notebook.projects.mapping"};
     private String classPath = null;
     private String modulePath = null;
     private String addModules = null;
     private boolean enablePreview = false;
+    private JsonObject notebookProjectMapping = new JsonObject();
     private List<String> implicitImports = null;
     private CompletableFuture<Void> initialized;
 
@@ -65,6 +71,10 @@ public List<String> getImplicitImports() {
         return implicitImports;
     }
 
+    public JsonObject getNotebookProjectMapping() {
+        return notebookProjectMapping;
+    }
+
     private NotebookConfigs() {
 
     }
@@ -121,6 +131,10 @@ private CompletableFuture<Void> initializeConfigs() throws InterruptedException,
                         implicitImports = ((JsonArray) c.get(4)).asList().stream().map((elem) -> elem.getAsString()).toList();
 
                     }
+                    if (c.get(5) != null) {
+                        notebookProjectMapping = (JsonObject) c.get(5);
+
+                    }
                 }
             });
 

nbcode/notebooks/src/org/netbeans/modules/nbcode/java/notebook/NotebookSessionManager.java

@@ -15,18 +15,26 @@
  */
 package org.netbeans.modules.nbcode.java.notebook;
 
+import com.google.gson.JsonObject;
+import java.net.URI;
+import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CancellationException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
+import java.util.function.BiConsumer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import jdk.jshell.JShell;
 import org.eclipse.lsp4j.NotebookDocument;
+import org.netbeans.api.project.Project;
 import static org.netbeans.modules.nbcode.java.notebook.NotebookUtils.checkEmptyString;
+import org.netbeans.modules.nbcode.java.project.ProjectConfigurationUtils;
+import org.netbeans.modules.nbcode.java.project.ProjectContext;
 
 /**
  *
@@ -56,45 +64,41 @@ private static class Singleton {
         private static final NotebookSessionManager instance = new NotebookSessionManager();
     }
 
-    private CompletableFuture<JShell> jshellBuilder(JshellStreamsHandler streamsHandler) {
-        return CompletableFuture.supplyAsync(() -> {
-            try {
-                NotebookConfigs.getInstance().getInitialized().get();
-            } catch (InterruptedException ex) {
-                LOG.log(Level.WARNING, "InterruptedException occurred while getting notebook configs: {0}", ex.getMessage());
-            } catch (ExecutionException ex) {
-                LOG.log(Level.WARNING, "ExecutionException occurred while getting notebook configs: {0}", ex.getMessage());
-            }
-            List<String> compilerOptions = getCompilerOptions();
-            List<String> remoteOptions = getRemoteVmOptions();
-            if (compilerOptions.isEmpty()) {
-                return JShell.builder()
-                        .out(streamsHandler.getPrintOutStream())
-                        .err(streamsHandler.getPrintErrStream())
-                        .in(streamsHandler.getInputStream())
-                        .compilerOptions()
-                        .remoteVMOptions()
-                        .build();
-            } else {
-                return JShell.builder()
-                        .out(streamsHandler.getPrintOutStream())
-                        .err(streamsHandler.getPrintErrStream())
-                        .in(streamsHandler.getInputStream())
-                        .compilerOptions(compilerOptions.toArray(new String[0]))
-                        .remoteVMOptions(remoteOptions.toArray(new String[0]))
-                        .build();
-            }
+    private CompletableFuture<JShell> jshellBuilder(String notebookUri, JshellStreamsHandler streamsHandler) {
+        return NotebookConfigs.getInstance().getInitialized()
+                .thenCompose(v -> getProjectContextForNotebook(notebookUri)
+                .thenApply(prj -> jshellBuildWithProject(prj, streamsHandler)
+                )).exceptionally(throwable -> {
+            LOG.log(Level.WARNING, "Failed to get project context, using default JShell configuration", throwable);
+            return jshellBuildWithProject(null, streamsHandler);
         });
     }
 
+    private JShell jshellBuildWithProject(Project prj, JshellStreamsHandler streamsHandler) {
+        List<String> compilerOptions = getCompilerOptions(prj);
+        List<String> remoteOptions = getRemoteVmOptions(prj);
+
+        JShell.Builder builder = JShell.builder()
+                .out(streamsHandler.getPrintOutStream())
+                .err(streamsHandler.getPrintErrStream())
+                .in(streamsHandler.getInputStream());
+
+        if (!compilerOptions.isEmpty()) {
+            builder.compilerOptions(compilerOptions.toArray(new String[0]))
+                    .remoteVMOptions(remoteOptions.toArray(new String[0]));
+        }
+
+        return builder.build();
+    }
+
     public CompletableFuture<JShell> createSession(NotebookDocument notebookDoc) {
         String notebookId = notebookDoc.getUri();
 
         return sessions.computeIfAbsent(notebookId, id -> {
             JshellStreamsHandler handler = new JshellStreamsHandler(id, CodeEval.getInstance().outStreamFlushCb, CodeEval.getInstance().errStreamFlushCb);
             jshellStreamsMap.put(id, handler);
 
-            CompletableFuture<JShell> future = jshellBuilder(handler);
+            CompletableFuture<JShell> future = jshellBuilder(notebookDoc.getUri(), handler);
 
             future.thenAccept(jshell -> onJshellInit(notebookId, jshell))
                     .exceptionally(ex -> {
@@ -106,58 +110,85 @@ public CompletableFuture<JShell> createSession(NotebookDocument notebookDoc) {
         });
     }
 
-    private List<String> getCompilerOptions() {
+    private List<String> getCompilerOptions(Project prj) {
         List<String> compilerOptions = new ArrayList<>();
-        String classpath = NotebookConfigs.getInstance().getClassPath();
-        String modulePath = NotebookConfigs.getInstance().getModulePath();
-        String addModules = NotebookConfigs.getInstance().getAddModules();
-        boolean isEnablePreview = NotebookConfigs.getInstance().isEnablePreview();
-        String notebookJdkVersion = NotebookConfigs.getInstance().getJdkVersion();
-
-        if (!checkEmptyString(classpath)) {
-            compilerOptions.add(CLASS_PATH);
-            compilerOptions.add(classpath);
-        }
-        if (!checkEmptyString(modulePath)) {
-            compilerOptions.add(MODULE_PATH);
-            compilerOptions.add(modulePath);
-        }
-        if (!checkEmptyString(addModules)) {
-            compilerOptions.add(ADD_MODULES);
-            compilerOptions.add(addModules);
-        }
-        if (isEnablePreview) {
+        NotebookConfigs configs = NotebookConfigs.getInstance();
+
+        BiConsumer<String, String> addOption = (flag, value) -> {
+            if (!checkEmptyString(value)) {
+                compilerOptions.add(flag);
+                compilerOptions.add(value);
+            }
+        };
+
+        addOption.accept(CLASS_PATH, configs.getClassPath());
+        addOption.accept(MODULE_PATH, configs.getModulePath());
+        addOption.accept(ADD_MODULES, configs.getAddModules());
+
+        if (configs.isEnablePreview()) {
             compilerOptions.add(ENABLE_PREVIEW);
             compilerOptions.add(SOURCE_FLAG);
-            compilerOptions.add(notebookJdkVersion);
+            compilerOptions.add(configs.getJdkVersion());
+        }
+
+        if (prj != null) {
+            List<String> projOptions = ProjectConfigurationUtils.compilerOptions(prj);
+            Map<String, String> prjConfigMap = new HashMap<>();
+            for (int i = 0; i < projOptions.size() - 1; i += 2) {
+                prjConfigMap.put(projOptions.get(i), projOptions.get(i + 1));
+            }
+
+            if (checkEmptyString(configs.getClassPath()) && prjConfigMap.containsKey(CLASS_PATH)) {
+                addOption.accept(CLASS_PATH, prjConfigMap.get(CLASS_PATH));
+            }
+            if (checkEmptyString(configs.getModulePath()) && prjConfigMap.containsKey(MODULE_PATH)) {
+                addOption.accept(MODULE_PATH, prjConfigMap.get(MODULE_PATH));
+            }
+            if (checkEmptyString(configs.getAddModules()) && prjConfigMap.containsKey(ADD_MODULES)) {
+                addOption.accept(ADD_MODULES, prjConfigMap.get(ADD_MODULES));
+            }
         }
 
         return compilerOptions;
     }
 
-    private List<String> getRemoteVmOptions() {
+    private List<String> getRemoteVmOptions(Project prj) {
         List<String> remoteOptions = new ArrayList<>();
-        String classpath = NotebookConfigs.getInstance().getClassPath();
-        String modulePath = NotebookConfigs.getInstance().getModulePath();
-        String addModules = NotebookConfigs.getInstance().getAddModules();
-        boolean isEnablePreview = NotebookConfigs.getInstance().isEnablePreview();
-
-        if (!checkEmptyString(classpath)) {
-            remoteOptions.add(CLASS_PATH);
-            remoteOptions.add(classpath);
-        }
-        if (!checkEmptyString(modulePath)) {
-            remoteOptions.add(MODULE_PATH);
-            remoteOptions.add(modulePath);
-        }
-        if (!checkEmptyString(addModules)) {
-            remoteOptions.add(ADD_MODULES);
-            remoteOptions.add(addModules);
-        }
+        NotebookConfigs configs = NotebookConfigs.getInstance();
+        boolean isEnablePreview = configs.isEnablePreview();
+
+        BiConsumer<String, String> addOption = (flag, value) -> {
+            if (!checkEmptyString(value)) {
+                remoteOptions.add(flag);
+                remoteOptions.add(value);
+            }
+        };
+
+        addOption.accept(CLASS_PATH, configs.getClassPath());
+        addOption.accept(MODULE_PATH, configs.getModulePath());
+        addOption.accept(ADD_MODULES, configs.getAddModules());
+
         if (isEnablePreview) {
             remoteOptions.add(ENABLE_PREVIEW);
         }
 
+        if (prj != null) {
+            List<String> projOptions = ProjectConfigurationUtils.launchVMOptions(prj);
+            Map<String, String> prjConfigMap = new HashMap<>();
+            for (int i = 0; i < projOptions.size() - 1; i += 2) {
+                prjConfigMap.put(projOptions.get(i), projOptions.get(i + 1));
+            }
+
+            if (checkEmptyString(configs.getClassPath()) && prjConfigMap.containsKey(CLASS_PATH)) {
+                addOption.accept(CLASS_PATH, prjConfigMap.get(CLASS_PATH));
+            }
+            if (checkEmptyString(configs.getModulePath()) && prjConfigMap.containsKey(MODULE_PATH)) {
+                addOption.accept(MODULE_PATH, prjConfigMap.get(MODULE_PATH));
+            }
+            if (checkEmptyString(configs.getAddModules()) && prjConfigMap.containsKey(ADD_MODULES)) {
+                addOption.accept(ADD_MODULES, prjConfigMap.get(ADD_MODULES));
+            }
+        }
         return remoteOptions;
     }
 
@@ -205,4 +236,28 @@ public void closeSession(String notebookUri) {
             handler.close();
         }
     }
+
+    private CompletableFuture<Project> getProjectContextForNotebook(String notebookUri) {
+        JsonObject mapping = NotebookConfigs.getInstance().getNotebookProjectMapping();
+        String notebookPath = URI.create(notebookUri).getPath();
+        String projectKey = mapping.has(notebookPath)
+                ? Paths.get(mapping.get(notebookPath).getAsString()).toUri().toString()
+                : notebookUri;
+
+        Project prj = ProjectContext.getProject(projectKey);
+
+        if (prj == null) {
+            LOG.log(Level.WARNING, "Project not found or not open in workspace: {0}", projectKey);
+            return null;
+        }
+
+        return ProjectConfigurationUtils.buildProject(prj).thenApply(buildStatus -> {
+            if (!buildStatus) {
+                LOG.log(Level.WARNING, "Error while building project: {0}", projectKey);
+                return null;
+            }
+            return prj;
+        });
+
+    }
 }