Simpler JLine integration

gbrail · gbrail · commit c0f01fa2bd7b · 2026-01-10T12:00:04.000-08:00
Move the JLine integration back into the "rhino-tools" module, but make
it optional using "compileOnly". The module will use JLine if it's in
the classpath and will fall back gracefully if it's not.

Include JLine in the "rhino-all" module so that the "rhino-all" JAR
contains JLine by default so that we have a nice initial user
experience.

This will give us command-line editing and history. Command completion
and highlighting are a task for another day.
diff --git a/rhino-all/build.gradle b/rhino-all/build.gradle
@@ -16,7 +16,10 @@ dependencies {
     implementation project(':rhino')
     implementation project(':rhino-tools')
     implementation project(':rhino-xml')
-    implementation project(':rhino-cli')
+    runtimeOnly 'org.jline:jline-terminal:3.30.0'
+    runtimeOnly 'org.jline:jline-reader:3.30.0'
+    runtimeOnly 'org.jline:jline-terminal-ffm:3.30.0'
+    runtimeOnly 'org.jline:jline-terminal-jni:3.30.0'
 }
 
 shadowJar {
diff --git a/rhino-cli/build.gradle b/rhino-cli/build.gradle
diff --git a/rhino-cli/src/main/java/module-info.java b/rhino-cli/src/main/java/module-info.java
diff --git a/rhino-cli/src/main/resources/META-INF/services/org.mozilla.javascript.tools.ConsoleProvider b/rhino-cli/src/main/resources/META-INF/services/org.mozilla.javascript.tools.ConsoleProvider
diff --git a/rhino-tools/build.gradle b/rhino-tools/build.gradle
@@ -4,6 +4,8 @@ plugins {
 
 dependencies {
     implementation project(':rhino')
+    compileOnly 'org.jline:jline-terminal:3.30.0'
+    compileOnly 'org.jline:jline-reader:3.30.0'
     testImplementation project(':testutils')
 }
 
diff --git a/rhino-tools/src/main/java/module-info.java b/rhino-tools/src/main/java/module-info.java
@@ -1,6 +1,8 @@
 module org.mozilla.rhino.tools {
     requires transitive org.mozilla.rhino;
     requires transitive java.desktop;
+    requires static org.jline.terminal;
+    requires static org.jline.reader;
 
     exports org.mozilla.javascript.tools;
     exports org.mozilla.javascript.tools.debugger;
@@ -10,5 +12,6 @@
     uses org.mozilla.javascript.tools.ConsoleProvider;
 
     provides org.mozilla.javascript.tools.ConsoleProvider with
-            org.mozilla.javascript.tools.shell.BasicConsoleProvider;
+            org.mozilla.javascript.tools.shell.BasicConsoleProvider,
+            org.mozilla.javascript.tools.shell.JLineConsoleProvider;
 }
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/Console.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/Console.java
@@ -1,13 +1,14 @@
 package org.mozilla.javascript.tools;
 
+import java.io.Closeable;
 import java.io.IOException;
 import java.io.PrintStream;
 
 /**
  * A generic interface for a console that supports input from the user and displays input on the
  * screen.
  */
-public interface Console {
+public interface Console extends Closeable {
     String getImplementation();
 
     String readLine(String prompt) throws IOException;
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/ConsoleProvider.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/ConsoleProvider.java
@@ -1,14 +1,12 @@
 package org.mozilla.javascript.tools;
 
-import org.mozilla.javascript.Scriptable;
-
 /**
  * This is a service interface to provide consoles. It allows there to be multiple console
  * implementations at runtime based on classpath.
  */
 public interface ConsoleProvider {
     /** Create the console. Must not be called unless "isSupported" returned true. */
-    Console newConsole(Scriptable scope);
+    Console newConsole();
 
     /** Return whether the console is possible to use at all */
     boolean isSupported();
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/BasicConsole.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/BasicConsole.java
@@ -23,6 +23,9 @@ public BasicConsole() {
         setErr(System.err);
     }
 
+    @Override
+    public void close() throws IOException {}
+
     @Override
     public String getImplementation() {
         return "Default console";
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/BasicConsoleProvider.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/BasicConsoleProvider.java
@@ -1,12 +1,11 @@
 package org.mozilla.javascript.tools.shell;
 
-import org.mozilla.javascript.Scriptable;
 import org.mozilla.javascript.tools.Console;
 import org.mozilla.javascript.tools.ConsoleProvider;
 
 public class BasicConsoleProvider implements ConsoleProvider {
     @Override
-    public Console newConsole(Scriptable scope) {
+    public Console newConsole() {
         return new BasicConsole();
     }
 
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Global.java
@@ -64,15 +64,37 @@
  * @author Norris Boyd
  */
 public class Global extends ImporterTopLevel {
-    static final long serialVersionUID = 4029130780977538005L;
+    private static final long serialVersionUID = 4029130780977538005L;
+
+    private static final String[] TOP_COMMANDS = {
+        "defineClass",
+        "deserialize",
+        "doctest",
+        "gc",
+        "help",
+        "load",
+        "loadClass",
+        "print",
+        "quit",
+        "readline",
+        "readFile",
+        "readUrl",
+        "runCommand",
+        "seal",
+        "serialize",
+        "spawn",
+        "sync",
+        "toint32",
+        "version",
+        "write"
+    };
 
     NativeArray history;
-    boolean attemptedJLineLoad;
     private Console console;
     private boolean sealedStdLib = false;
     boolean initialized;
     private QuitAction quitAction;
-    private String[] prompts = {"js> ", "  > "};
+    private static final String[] prompts = {"js> ", "  > "};
     private HashMap<String, String> doctestCanonicalizations;
 
     public Global() {}
@@ -106,29 +128,7 @@ public void init(Context cx) {
         // that these functions are not part of ECMA.
         initStandardObjects(cx, sealedStdLib);
         NativeConsole.init(this, sealedStdLib, new ShellConsolePrinter());
-        String[] names = {
-            "defineClass",
-            "deserialize",
-            "doctest",
-            "gc",
-            "help",
-            "load",
-            "loadClass",
-            "print",
-            "quit",
-            "readline",
-            "readFile",
-            "readUrl",
-            "runCommand",
-            "seal",
-            "serialize",
-            "spawn",
-            "sync",
-            "toint32",
-            "version",
-            "write"
-        };
-        defineFunctionProperties(names, Global.class, ScriptableObject.DONTENUM);
+        defineFunctionProperties(TOP_COMMANDS, Global.class, ScriptableObject.DONTENUM);
 
         // Set up "environment" in the global scope to provide access to the
         // System environment variables.
@@ -142,6 +142,15 @@ public void init(Context cx) {
         initialized = true;
     }
 
+    public void cleanup() {
+        if (console != null) {
+            try {
+                console.close();
+            } catch (IOException ignore) {
+            }
+        }
+    }
+
     public Require installRequire(Context cx, List<String> modulePath, boolean sandboxed) {
         RequireBuilder rb = new RequireBuilder();
         rb.setSandboxed(sandboxed);
@@ -400,8 +409,8 @@ public int runDoctest(
             Context cx, Scriptable scope, String session, String sourceName, int lineNumber) {
         doctestCanonicalizations = new HashMap<String, String>();
         String[] lines = session.split("\r\n?|\n", -1);
-        String prompt0 = this.prompts[0].trim();
-        String prompt1 = this.prompts[1].trim();
+        String prompt0 = prompts[0].trim();
+        String prompt1 = prompts[1].trim();
         int testCount = 0;
         int i = 0;
         while (i < lines.length && !lines[i].trim().startsWith(prompt0)) {
@@ -721,13 +730,13 @@ private Console loadNewConsole() {
         // Find the first interactive, command-line editing console
         for (var p : loader) {
             if (p.isSupported() && p.supportsEditing()) {
-                return p.newConsole(this);
+                return p.newConsole();
             }
         }
         // Find the first one that at least works
         for (var p : loader) {
             if (p.isSupported()) {
-                return p.newConsole(this);
+                return p.newConsole();
             }
         }
         // Fall back
@@ -740,6 +749,12 @@ private Console loadNewConsole() {
      */
     private BasicConsole getBasicConsole() {
         if (!(console instanceof BasicConsole)) {
+            if (console != null) {
+                try {
+                    console.close();
+                } catch (IOException ignore) {
+                }
+            }
             console = new BasicConsole();
         }
         return (BasicConsole) console;
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JLineConsole.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JLineConsole.java
@@ -1,23 +1,28 @@
-package org.mozilla.javascript.cli;
+package org.mozilla.javascript.tools.shell;
 
+import java.io.IOException;
 import java.io.PrintStream;
 import org.jline.reader.EndOfFileException;
 import org.jline.reader.LineReader;
 import org.jline.reader.LineReaderBuilder;
 import org.jline.reader.UserInterruptException;
 import org.jline.terminal.Terminal;
-import org.mozilla.javascript.Scriptable;
 import org.mozilla.javascript.tools.Console;
 
 public class JLineConsole implements Console {
     private final Terminal terminal;
     private final LineReader reader;
 
-    JLineConsole(Terminal t, Scriptable scope) {
+    JLineConsole(Terminal t) {
         this.terminal = t;
         this.reader = LineReaderBuilder.builder().terminal(t).build();
     }
 
+    @Override
+    public void close() throws IOException {
+        terminal.close();
+    }
+
     @Override
     public String getImplementation() {
         return "JLine " + terminal.getType();
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JLineConsoleProvider.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/JLineConsoleProvider.java
@@ -1,9 +1,7 @@
-package org.mozilla.javascript.cli;
+package org.mozilla.javascript.tools.shell;
 
-import java.io.IOException;
 import org.jline.terminal.Terminal;
 import org.jline.terminal.TerminalBuilder;
-import org.mozilla.javascript.Scriptable;
 import org.mozilla.javascript.tools.Console;
 import org.mozilla.javascript.tools.ConsoleProvider;
 
@@ -16,16 +14,17 @@ public JLineConsoleProvider() {
             // Initialize JLine so it will try to use a fancy console, but
             // won't print out a warning if it can't.
             t = TerminalBuilder.builder().system(true).dumb(true).build();
-        } catch (IOException ioe) {
+        } catch (Throwable e) {
+            // Most likely reason for this is that JLine isn't in the path
             t = null;
         }
         terminal = t;
     }
 
     @Override
-    public Console newConsole(Scriptable scope) {
+    public Console newConsole() {
         assert terminal != null;
-        return new JLineConsole(terminal, scope);
+        return new JLineConsole(terminal);
     }
 
     @Override
diff --git a/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Main.java b/rhino-tools/src/main/java/org/mozilla/javascript/tools/shell/Main.java
@@ -132,7 +132,7 @@ public void quit(Context cx, int exitCode) {
      * it with the current thread. Then set up the execution environment and begin to execute
      * scripts.
      */
-    public static void main(String args[]) {
+    public static void main(String[] args) {
         try {
             if (RhinoConfig.get("rhino.use_java_policy_security", false)) {
                 initJavaPolicySecuritySupport();
@@ -141,14 +141,19 @@ public static void main(String args[]) {
             ex.printStackTrace(System.err);
         }
 
-        int result = exec(args);
+        int result;
+        try {
+            result = exec(args);
+        } finally {
+            global.cleanup();
+        }
         if (result != 0) {
             System.exit(result);
         }
     }
 
     /** Execute the given arguments, but don't System.exit at the end. */
-    public static int exec(String origArgs[]) {
+    public static int exec(String[] origArgs) {
         errorReporter = new ToolErrorReporter(false, global.getConsole().getErr());
         shellContextFactory.setErrorReporter(errorReporter);
         String[] args = processOptions(origArgs);
diff --git a/rhino-tools/src/main/resources/META-INF/services/org.mozilla.javascript.tools.ConsoleProvider b/rhino-tools/src/main/resources/META-INF/services/org.mozilla.javascript.tools.ConsoleProvider
@@ -1 +1,2 @@
 org.mozilla.javascript.tools.shell.BasicConsoleProvider
+org.mozilla.javascript.tools.shell.JLineConsoleProvider
diff --git a/settings.gradle b/settings.gradle
@@ -4,6 +4,5 @@ plugins {
 }
 rootProject.name = 'rhino-root'
 include 'rhino', 'rhino-engine', 'rhino-tools', 'rhino-xml', 'rhino-all', 'examples', 'testutils', 'tests', 'benchmarks'
-include 'rhino-cli'
 include 'rhino-kotlin'
 include 'it-android'

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,8 @@ plugins {`
`4`	`4`
`5`	`5`	`dependencies {`
`6`	`6`	`implementation project(':rhino')`
	`7`	`+ compileOnly 'org.jline:jline-terminal:3.30.0'`
	`8`	`+ compileOnly 'org.jline:jline-reader:3.30.0'`
`7`	`9`	`testImplementation project(':testutils')`
`8`	`10`	`}`
`9`	`11`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,9 @@ public BasicConsole() {`
`23`	`23`	`setErr(System.err);`
`24`	`24`	`}`
`25`	`25`
	`26`	`+ @Override`
	`27`	`+ public void close() throws IOException {}`
	`28`	`+`
`26`	`29`	`@Override`
`27`	`30`	`public String getImplementation() {`
`28`	`31`	`return "Default console";`