Bring in a JLine-based console in a modular way

Replace the old code that tried to use reflection to load a JLine
console with a new "rhino-cli" module that includes JLine. If this
module is present and we are on an interactive terminal, we will use a
JLine console which supports command history and editing.
Include this module in rhino-all so that the default Rhino CLI uses it.

Author: gbrail

rhino-all/build.gradle

@@ -16,12 +16,19 @@ dependencies {
     implementation project(':rhino')
     implementation project(':rhino-tools')
     implementation project(':rhino-xml')
+    implementation project(':rhino-cli')
 }
 
 shadowJar {
     // Ensure that the "jar" from this step is the shadowed one that we want to 
     // publish in Maven.
     archiveClassifier.set('')
+    // Merge service files, but fail on other duplicates.
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE // Or WARN.
+    mergeServiceFiles()
+    filesNotMatching('META-INF/services/**') {
+        duplicatesStrategy = DuplicatesStrategy.FAIL // Or FAIL.
+    }
 }
 
 startScripts {

rhino-cli/build.gradle

@@ -0,0 +1,51 @@
+plugins {
+    id 'rhino.library-conventions'
+}
+
+dependencies {
+    implementation project(':rhino')
+    implementation project(':rhino-tools')
+    implementation 'org.jline:jline-terminal:3.30.0'
+    implementation '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'
+}
+
+publishing {
+    publications {
+        rhinotools(MavenPublication) {
+            from components.java
+            artifacts = [jar, sourceJar, javadocJar]
+            pom.withXml {
+                def root = asNode()
+
+                root.appendNode('name', 'rhino-cli')
+                root.appendNode('description', "Rhino CLI support for JLine")
+                root.appendNode("url", "https://mozilla.github.io/rhino/")
+
+                def p = root.appendNode("parent")
+                p.appendNode("groupId", "org.sonatype.oss")
+                p.appendNode("artifactId", "oss-parent")
+                p.appendNode("version", "7")
+
+                def l = root.appendNode("licenses").appendNode("license")
+                l.appendNode("name", "Mozilla Public License, Version 2.0")
+                l.appendNode("url", "http://www.mozilla.org/MPL/2.0/index.txt")
+
+                def scm = root.appendNode("scm")
+                scm.appendNode("connection", "scm:git:[email protected]:mozilla/rhino.git")
+                scm.appendNode("developerConnection", "scm:git:[email protected]:mozilla/rhino.git")
+                scm.appendNode("url", "[email protected]:mozilla/rhino.git")
+
+                def o = root.appendNode("organization")
+                o.appendNode("name", "The Mozilla Foundation")
+                o.appendNode("url", "http://www.mozilla.org")
+
+                def d = root.appendNode("developers")
+                def dd = d.appendNode("developer")
+                dd.appendNode("name", "Greg Brail")
+                dd.appendNode("email", "[email protected]")
+            }
+        }
+    }
+}

rhino-cli/src/main/java/module-info.java

@@ -0,0 +1,11 @@
+module org.mozilla.rhino.cli {
+    requires org.mozilla.rhino;
+    requires org.mozilla.rhino.tools;
+    requires org.jline.terminal;
+    requires org.jline.reader;
+
+    exports org.mozilla.javascript.cli;
+
+    provides org.mozilla.javascript.tools.ConsoleProvider with
+            org.mozilla.javascript.cli.JLineConsoleProvider;
+}

rhino-cli/src/main/java/org/mozilla/javascript/cli/JLineConsole.java

@@ -0,0 +1,74 @@
+package org.mozilla.javascript.cli;
+
+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) {
+        this.terminal = t;
+        this.reader = LineReaderBuilder.builder().terminal(t).build();
+    }
+
+    @Override
+    public String getImplementation() {
+        return "JLine " + terminal.getType();
+    }
+
+    @Override
+    public String readLine(String prompt) {
+        try {
+            return reader.readLine(prompt);
+        } catch (UserInterruptException | EndOfFileException e) {
+            // This will cause the "main" to cleanly exit
+            return null;
+        }
+    }
+
+    @Override
+    public String readLine() {
+        try {
+            return reader.readLine();
+        } catch (UserInterruptException | EndOfFileException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public void print(String msg) {
+        terminal.writer().print(msg);
+    }
+
+    @Override
+    public void println(String msg) {
+        terminal.writer().println(msg);
+    }
+
+    @Override
+    public void println() {
+        terminal.writer().println();
+    }
+
+    @Override
+    public void flush() {
+        terminal.writer().flush();
+    }
+
+    @Override
+    public PrintStream getOut() {
+        return new PrintStream(terminal.output());
+    }
+
+    @Override
+    public PrintStream getErr() {
+        return new PrintStream(terminal.output());
+    }
+}

rhino-cli/src/main/java/org/mozilla/javascript/cli/JLineConsoleProvider.java

@@ -0,0 +1,43 @@
+package org.mozilla.javascript.cli;
+
+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;
+
+public class JLineConsoleProvider implements ConsoleProvider {
+    private final Terminal terminal;
+
+    public JLineConsoleProvider() {
+        Terminal t;
+        try {
+            // 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) {
+            t = null;
+        }
+        terminal = t;
+    }
+
+    @Override
+    public Console newConsole(Scriptable scope) {
+        assert terminal != null;
+        return new JLineConsole(terminal, scope);
+    }
+
+    @Override
+    public boolean isSupported() {
+        // Only allow JLine to be used if we have full functionality.
+        return (terminal != null
+                && !Terminal.TYPE_DUMB.equals(terminal.getType())
+                && !Terminal.TYPE_DUMB_COLOR.equals(terminal.getType()));
+    }
+
+    @Override
+    public boolean supportsEditing() {
+        return true;
+    }
+}

rhino-cli/src/main/resources/META-INF/services/org.mozilla.javascript.tools.ConsoleProvider

@@ -0,0 +1 @@
+org.mozilla.javascript.cli.JLineConsoleProvider

rhino-tools/src/main/java/module-info.java

@@ -6,4 +6,9 @@
     exports org.mozilla.javascript.tools.debugger;
     exports org.mozilla.javascript.tools.jsc;
     exports org.mozilla.javascript.tools.shell;
+
+    uses org.mozilla.javascript.tools.ConsoleProvider;
+
+    provides org.mozilla.javascript.tools.ConsoleProvider with
+            org.mozilla.javascript.tools.shell.BasicConsoleProvider;
 }

rhino-tools/src/main/java/org/mozilla/javascript/tools/Console.java

@@ -0,0 +1,28 @@
+package org.mozilla.javascript.tools;
+
+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 {
+    String getImplementation();
+
+    String readLine(String prompt) throws IOException;
+
+    String readLine() throws IOException;
+
+    void print(String msg);
+
+    void println(String msg);
+
+    void println();
+
+    void flush();
+
+    PrintStream getOut();
+
+    PrintStream getErr();
+}

rhino-tools/src/main/java/org/mozilla/javascript/tools/ConsoleProvider.java

@@ -0,0 +1,18 @@
+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);
+
+    /** Return whether the console is possible to use at all */
+    boolean isSupported();
+
+    /** Return whether this console supports interactive command-line editing. */
+    boolean supportsEditing();
+}

rhino-tools/src/main/java/org/mozilla/javascript/tools/ToolErrorReporter.java

@@ -25,9 +25,9 @@
  * <p>Currently used by both the shell and the compiler.
  */
 public class ToolErrorReporter implements ErrorReporter {
-
     public ToolErrorReporter(boolean reportWarnings) {
-        this(reportWarnings, System.err);
+        this.reportWarnings = reportWarnings;
+        this.err = System.err;
     }
 
     public ToolErrorReporter(boolean reportWarnings, PrintStream err) {
@@ -190,5 +190,5 @@ private String buildIndicator(int offset) {
     private static final String messagePrefix = "js: ";
     private boolean hasReportedErrorFlag;
     private boolean reportWarnings;
-    private PrintStream err;
+    private final PrintStream err;
 }