feat: add JavaScript console and reinitialize action, enhance script processing to isolate per-project

kunstmusik · kunstmusik · commit 1e49b4c52f2f · 2026-04-15T14:44:14.000-04:00
diff --git a/ChangeLog.md b/ChangeLog.md
@@ -27,6 +27,8 @@ information.
   * Parsing and CSD import handle both single-line and multi-line modern declarations
   * Newly created UDOs and Effects default to application setting default (new setting in Program Settings for "Default UDO/Effects Style"); existing projects load as classic for backward compatibility
 
+* Orchestra: added "Replace Instrument" action to context menu
+
 ### Updated
 
 * Introduced new Time Unit system encompassing time signatures, measures, new tempo ruler, and new time units:
diff --git a/blue-core/src/main/java/blue/scripting/JavaScriptProxy.java b/blue-core/src/main/java/blue/scripting/JavaScriptProxy.java
@@ -13,19 +13,29 @@
  * @author unascribed
  * @version 1.0
  */
+import blue.BlueData;
 import blue.BlueSystem;
+import java.io.File;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.WeakHashMap;
 import javax.script.ScriptContext;
 import javax.script.ScriptEngine;
 import javax.script.ScriptException;
 import org.netbeans.api.scripting.Scripting;
 
 public class JavaScriptProxy {
 
-    private static ScriptEngine engine;
+    private static final Map<BlueData, ProjectEngineState> projectEngineStates
+        = new WeakHashMap<>();
 
-    static {
+    private static ProjectEngineState defaultEngineState;
 
-    }
+    private static final ArrayList<JavaScriptProxyListener> listeners
+            = new ArrayList<>();
 
     public static synchronized final void reinitialize() {
 //        if (cx != null) {
@@ -34,20 +44,37 @@ public static synchronized final void reinitialize() {
 //        cx = Context.enter();
 //        scope = cx.initStandardObjects(null);
 //        engine = new ScriptEngineManager().getEngineByName("graal.js");
-        engine = Scripting.createManager().getEngineByMimeType("text/javascript");
-        engine.getContext().setAttribute(ScriptEngine.FILENAME, "script.mjs", ScriptContext.ENGINE_SCOPE);
+    ProjectEngineState state = createEngineState();
+    BlueData currentData = BlueSystem.getCurrentBlueData();
+
+    if (currentData == null) {
+        defaultEngineState = state;
+    } else {
+        projectEngineStates.put(currentData, state);
+    }
+
+    ScriptContext context = state.engine.getContext();
+        context.setAttribute(ScriptEngine.FILENAME, "script.mjs", ScriptContext.ENGINE_SCOPE);
 //        Context.newBuilder("js").allowIO(true).currentWorkingDirectory(workingDirectory)
         System.out.println(BlueSystem.getString("scripting.js.reinitialized"));
+
+        for (JavaScriptProxyListener listener : listeners) {
+            listener.javascriptProxyReinitializePerformed();
+        }
+    }
+
+    public static synchronized void addJavaScriptProxyListener(JavaScriptProxyListener listener) {
+        listeners.add(listener);
+    }
+
+    public static synchronized void removeJavaScriptProxyListener(JavaScriptProxyListener listener) {
+        listeners.remove(listener);
     }
 
     public static synchronized final String processJavascriptScore(String script,
             double subjectiveDuration, String soundObjectId) throws ScriptException {
-        if (engine == null) {
-            reinitialize();
-        }
-        
-        
-        String returnScore = "";
+        ScriptEngine scriptEngine = getCurrentEngineState().engine;
+        setProjectBindings(scriptEngine);
 
         String init = "blueDuration = " + subjectiveDuration
                 + ";\n";
@@ -57,12 +84,12 @@ public static synchronized final String processJavascriptScore(String script,
 //        engine.setBindings(bindings, ScriptContext.GLOBAL_SCOPE);
         //engine.setContext(context);
         
-        engine.eval(init);
-        engine.eval(script);
+        scriptEngine.eval(init);
+        scriptEngine.eval(script);
 
 //        cx.evaluateString(scope, init, "init", 1, null);
 //        cx.evaluateString(scope, script, soundObjectId, 1, null);
-        var res = engine.get("score");
+        var res = scriptEngine.get("score");
 
 //        
 //
@@ -75,11 +102,8 @@ public static synchronized final String processJavascriptScore(String script,
 
     public static synchronized final String processJavascriptInstrument(String script,
             String instrumentId) throws ScriptException {
-        if (engine == null) {
-            reinitialize();
-        }
-        String returnInstrument = "";
-
+        ScriptEngine scriptEngine = getCurrentEngineState().engine;
+        setProjectBindings(scriptEngine);
         String init = "instrument = '';\n";
 
 //        try {
@@ -96,11 +120,174 @@ public static synchronized final String processJavascriptInstrument(String scrip
 //        } catch (JavaScriptException e) {
 //            System.out.println(e.getLocalizedMessage());
 //        }
-        engine.eval(init);
-        engine.eval(script);
-        var res = engine.get("instrument");
+        scriptEngine.eval(init);
+        scriptEngine.eval(script);
+        var res = scriptEngine.get("instrument");
         return java.util.Objects.toString(res, null);
 
     }
 
+    public static synchronized Object processScript(String script, Reader stdin,
+            Writer stdout, Writer stderr) throws ScriptException {
+        ProjectEngineState state = getCurrentEngineState();
+        ScriptEngine scriptEngine = state.engine;
+        setProjectBindings(scriptEngine);
+        state.consoleReader.setDelegate(stdin);
+        state.consoleWriter.setDelegate(stdout);
+        state.consoleErrorWriter.setDelegate(stderr);
+
+        try {
+            return scriptEngine.eval(script);
+        } finally {
+            state.consoleReader.clearDelegate();
+            state.consoleWriter.clearDelegate();
+            state.consoleErrorWriter.clearDelegate();
+        }
+    }
+
+    private static ProjectEngineState getCurrentEngineState() {
+        BlueData currentData = BlueSystem.getCurrentBlueData();
+
+        if (currentData == null) {
+            if (defaultEngineState == null) {
+                defaultEngineState = createEngineState();
+            }
+
+            return defaultEngineState;
+        }
+
+        ProjectEngineState state = projectEngineStates.get(currentData);
+
+        if (state == null) {
+            state = createEngineState();
+            projectEngineStates.put(currentData, state);
+        }
+
+        return state;
+    }
+
+    private static ProjectEngineState createEngineState() {
+        ScriptEngine engine = Scripting.createManager().getEngineByMimeType("text/javascript");
+        ProjectEngineState state = new ProjectEngineState(engine);
+        installConsoleIo(state, engine.getContext());
+        return state;
+    }
+
+    private static void installConsoleIo(ProjectEngineState state, ScriptContext context) {
+        state.consoleReader.clearDelegate();
+        state.consoleWriter.clearDelegate();
+        state.consoleErrorWriter.clearDelegate();
+
+        state.consoleReader.setFallback(context.getReader());
+        state.consoleWriter.setFallback(context.getWriter());
+        state.consoleErrorWriter.setFallback(context.getErrorWriter());
+
+        context.setReader(state.consoleReader);
+        context.setWriter(state.consoleWriter);
+        context.setErrorWriter(state.consoleErrorWriter);
+    }
+
+    private static void setProjectBindings(ScriptEngine scriptEngine) {
+        File currentDirFile = BlueSystem.getCurrentProjectDirectory();
+        String currentDir = currentDirFile == null ? ""
+                : currentDirFile.getAbsolutePath() + File.separator;
+
+        scriptEngine.put("blueData", BlueSystem.getCurrentBlueData());
+        scriptEngine.put("blueProjectDir", currentDir);
+    }
+
+    private static final class ProjectEngineState {
+
+        private final ScriptEngine engine;
+
+        private final DelegatingReader consoleReader = new DelegatingReader();
+
+        private final DelegatingWriter consoleWriter = new DelegatingWriter();
+
+        private final DelegatingWriter consoleErrorWriter = new DelegatingWriter();
+
+        private ProjectEngineState(ScriptEngine engine) {
+            this.engine = engine;
+        }
+    }
+
+    private static final class DelegatingReader extends Reader {
+
+        private Reader fallback;
+
+        private Reader delegate;
+
+        synchronized void setFallback(Reader fallback) {
+            this.fallback = fallback;
+        }
+
+        synchronized void setDelegate(Reader delegate) {
+            this.delegate = delegate;
+        }
+
+        synchronized void clearDelegate() {
+            this.delegate = null;
+        }
+
+        private synchronized Reader current() {
+            return delegate != null ? delegate : fallback;
+        }
+
+        @Override
+        public int read(char[] cbuf, int off, int len) throws IOException {
+            Reader reader = current();
+            return reader == null ? -1 : reader.read(cbuf, off, len);
+        }
+
+        @Override
+        public void close() {
+        }
+    }
+
+    private static final class DelegatingWriter extends Writer {
+
+        private Writer fallback;
+
+        private Writer delegate;
+
+        synchronized void setFallback(Writer fallback) {
+            this.fallback = fallback;
+        }
+
+        synchronized void setDelegate(Writer delegate) {
+            this.delegate = delegate;
+        }
+
+        synchronized void clearDelegate() {
+            this.delegate = null;
+        }
+
+        private synchronized Writer current() {
+            return delegate != null ? delegate : fallback;
+        }
+
+        @Override
+        public void write(char[] cbuf, int off, int len) throws IOException {
+            Writer writer = current();
+
+            if (writer != null) {
+                writer.write(cbuf, off, len);
+            }
+        }
+
+        @Override
+        public void flush() throws IOException {
+            Writer writer = current();
+
+            if (writer != null) {
+                writer.flush();
+            }
+        }
+
+        @Override
+        public void close() throws IOException {
+            flush();
+        }
+    }
+
 }
diff --git a/blue-core/src/main/java/blue/scripting/JavaScriptProxyListener.java b/blue-core/src/main/java/blue/scripting/JavaScriptProxyListener.java
@@ -0,0 +1,5 @@
+package blue.scripting;
+
+public interface JavaScriptProxyListener {
+    void javascriptProxyReinitializePerformed();
+}
diff --git a/blue-core/src/test/java/blue/scripting/JavaScriptProxyTest.java b/blue-core/src/test/java/blue/scripting/JavaScriptProxyTest.java
@@ -4,6 +4,10 @@
  */
 package blue.scripting;
 
+import blue.BlueData;
+import blue.BlueSystem;
+import java.io.StringReader;
+import java.io.StringWriter;
 import javax.script.ScriptException;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
@@ -34,10 +38,14 @@ public static void tearDownClass() throws Exception {
 
     @BeforeEach
     void setUp() {
+                BlueSystem.setCurrentBlueData(new BlueData());
+                BlueSystem.setCurrentProjectDirectory(null);
     }
 
     @AfterEach
     void tearDown() {
+                BlueSystem.setCurrentBlueData(null);
+                BlueSystem.setCurrentProjectDirectory(null);
     }
 
     /**
@@ -76,6 +84,53 @@ void testProcessJavascriptScore() throws ScriptException {
                 "score += '\\nhi\\n'", 0.0f, "unit test 3"));
     }
 
+    @Test
+        void testProcessScriptPreservesSharedEngineState() throws Exception {
+        JavaScriptProxy.reinitialize();
+
+        StringWriter stdout = new StringWriter();
+        StringWriter stderr = new StringWriter();
+
+        Object result = JavaScriptProxy.processScript("var counter = 2; counter;",
+                new StringReader(""), stdout, stderr);
+
+        assertEquals("2", String.valueOf(result));
+        assertEquals("", stderr.toString());
+
+        stdout.getBuffer().setLength(0);
+        result = JavaScriptProxy.processScript("counter += 5; counter;",
+                new StringReader(""), stdout, stderr);
+
+        assertEquals("7", String.valueOf(result));
+        assertEquals("", stderr.toString());
+    }
+
+    @Test
+    void testProcessScriptUsesPerProjectEngineState() throws Exception {
+        BlueData projectOne = new BlueData();
+        BlueData projectTwo = new BlueData();
+
+        BlueSystem.setCurrentBlueData(projectOne);
+        JavaScriptProxy.reinitialize();
+        assertEquals("p1", String.valueOf(JavaScriptProxy.processScript(
+                "var projectValue = 'p1'; projectValue;",
+                new StringReader(""), new StringWriter(), new StringWriter())));
+
+        BlueSystem.setCurrentBlueData(projectTwo);
+        JavaScriptProxy.reinitialize();
+        assertEquals("undefined", String.valueOf(JavaScriptProxy.processScript(
+                "typeof projectValue;",
+                new StringReader(""), new StringWriter(), new StringWriter())));
+        assertEquals("p2", String.valueOf(JavaScriptProxy.processScript(
+                "var projectValue = 'p2'; projectValue;",
+                new StringReader(""), new StringWriter(), new StringWriter())));
+
+        BlueSystem.setCurrentBlueData(projectOne);
+        assertEquals("p1", String.valueOf(JavaScriptProxy.processScript(
+                "projectValue;",
+                new StringReader(""), new StringWriter(), new StringWriter())));
+    }
+
     /**
      * Test of processJavascriptInstrument method, of class RhinoProxy.
      */
diff --git a/blue-ui-core/src/main/java/blue/ui/core/script/ReinitializeJavaScriptAction.java b/blue-ui-core/src/main/java/blue/ui/core/script/ReinitializeJavaScriptAction.java
diff --git a/blue-ui-core/src/main/java/blue/ui/core/script/javascript/JavaScriptConsoleTopComponent.java b/blue-ui-core/src/main/java/blue/ui/core/script/javascript/JavaScriptConsoleTopComponent.java
