This replaces the former JNI binding to the native GNU readline library + * and removes the corresponding native build steps.
+ * + * @author Mark Richters + */ +public class JLineReadline implements Readline { + + private final ConsoleReader reader; + private FileHistory history; + + public JLineReadline() throws IOException { + this(null, null); + } + + /** + * Package-private constructor used by tests to supply explicit streams + * instead of attaching to the real terminal. + */ + JLineReadline(InputStream in, OutputStream out) throws IOException { + reader = (in != null && out != null) + ? new ConsoleReader(in, out) + : new ConsoleReader(); + // USE uses '!' and '!!' to start SOIL statements. Disable JLine's + // history expansion so these characters are passed through verbatim. + reader.setExpandEvents(false); + } + + @Override + public String readline(String prompt) throws IOException { + return reader.readLine(prompt); + } + + @Override + public void usingHistory() { + reader.setHistoryEnabled(true); + } + + @Override + public void readHistory(String filename) throws IOException { + history = new FileHistory(new File(filename)); + reader.setHistory(history); + } + + @Override + public void writeHistory(String filename) throws IOException { + if (history != null) { + history.flush(); + } + } + + @Override + public void close() throws IOException { + reader.shutdown(); + } + + @Override + public boolean doEcho() { + return false; + } +} diff --git a/use-core/src/main/java/org/tzi/use/util/input/LineInput.java b/use-core/src/main/java/org/tzi/use/util/input/LineInput.java index 729a483b1..16a20ef2d 100644 --- a/use-core/src/main/java/org/tzi/use/util/input/LineInput.java +++ b/use-core/src/main/java/org/tzi/use/util/input/LineInput.java @@ -20,47 +20,45 @@ package org.tzi.use.util.input; import java.io.BufferedReader; +import java.io.IOException; import java.io.InputStreamReader; /** - * Interface for getting a suitable platform-dependent readline - * implementation. The GNU readline library is preferably used if - * installed. - * - * @author Mark Richters + * Factory for obtaining a suitable {@link Readline} implementation. + * + *For interactive use the pure-Java {@link JLineReadline} is returned, + * providing line editing and command history on all platforms. When no + * interactive terminal is available (e.g. the input is piped or USE runs in + * a headless environment) a plain {@link StreamReadline} reading from + * {@code System.in} is used instead.
+ * + * @author Mark Richters */ public class LineInput { // utility class private LineInput() {} - + /** - * Returns a readline implementation. If the native GNU readline - * library is available, return that. Otherwise, a stream readline - * implementation with System.in as source is returned. - * - * @param errorMessage if not null print a message when the native - * GNU readline library is not available, otherwise - * fail silently. + * Returns a {@link Readline} implementation for reading interactive user + * input. A JLine-backed implementation is used when a terminal is + * available; otherwise a simple stream-based implementation reading from + * {@code System.in} is returned. */ - public static Readline getUserInputReadline(String errorMessage) { - Readline rl = null; - try { - System.loadLibrary("natGNUReadline"); - rl = new GNUReadline(); - } catch (UnsatisfiedLinkError ex) { - if (errorMessage != null ) { - System.out.println(ex.toString()); - System.out.println(errorMessage); + public static Readline getUserInputReadline() { + if (System.console() != null) { + try { + return new JLineReadline(); + } catch (IOException ex) { + // JLine could not attach to the terminal; fall back below. } - BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); - // no echo, do protocol - rl = new StreamReadline(reader, false); } - return rl; + BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); + // no echo, do protocol + return new StreamReadline(reader, false); } - public static Readline getStreamReadline(BufferedReader reader, boolean doEcho, String string) { - return new StreamReadline(reader, doEcho, string); + public static Readline getStreamReadline(BufferedReader reader, boolean doEcho, String prompt) { + return new StreamReadline(reader, doEcho, prompt); } } diff --git a/use-core/src/main/java/org/tzi/use/util/input/Readline_test.java b/use-core/src/main/java/org/tzi/use/util/input/Readline_test.java index 38863288f..b4c002230 100644 --- a/use-core/src/main/java/org/tzi/use/util/input/Readline_test.java +++ b/use-core/src/main/java/org/tzi/use/util/input/Readline_test.java @@ -29,7 +29,7 @@ class Readline_test { public static void main(String[] args) { - Readline rl = LineInput.getUserInputReadline("readline library not found"); + Readline rl = LineInput.getUserInputReadline(); String line; try { do { diff --git a/use-core/src/main/java/org/tzi/use/util/input/natGNUReadline.c b/use-core/src/main/java/org/tzi/use/util/input/natGNUReadline.c deleted file mode 100644 index 7a4d73f42..000000000 --- a/use-core/src/main/java/org/tzi/use/util/input/natGNUReadline.c +++ /dev/null @@ -1,127 +0,0 @@ -/* - * USE - UML based specification environment - * Copyright (C) 1999-2004 Mark Richters, University of Bremen - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License as - * published by the Free Software Foundation; either version 2 of the - * License, or (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but - * WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - -/* $ProjectHeader: use 0.393 Wed, 16 May 2007 14:10:28 +0200 opti $ */ - -#includeA package-private constructor accepting explicit streams is used so the + * tests never need to attach to a real terminal.
+ */ +class JLineReadlineTest { + + private static JLineReadline readingFrom(String input) throws IOException { + return new JLineReadline(new ByteArrayInputStream(input.getBytes()), new ByteArrayOutputStream()); + } + + @Test + void readline_returnsInputLine() throws IOException { + try (var rl = readingFrom("hello\n")) { + assertEquals("hello", rl.readline("prompt> ")); + } + } + + @Test + void readline_returnsNullAtEndOfStream() throws IOException { + try (var rl = readingFrom("")) { + assertNull(rl.readline("prompt> ")); + } + } + + @Test + void doEcho_returnsFalse() throws IOException { + try (var rl = readingFrom("")) { + assertFalse(rl.doEcho()); + } + } + + @Test + void usingHistory_doesNotThrow() throws IOException { + try (var rl = readingFrom("")) { + assertDoesNotThrow(rl::usingHistory); + } + } + + @Test + void writeHistory_persistsEnteredCommandsToFile(@TempDir Path tmp) throws IOException { + Path histFile = tmp.resolve(".use_history_test"); + + try (var rl = new JLineReadline( + new ByteArrayInputStream("cmd1\ncmd2\n".getBytes()), new ByteArrayOutputStream())) { + rl.usingHistory(); + rl.readHistory(histFile.toString()); + rl.readline("> "); + rl.readline("> "); + rl.writeHistory(histFile.toString()); + } + + assertTrue(histFile.toFile().exists(), "history file should be created"); + assertTrue(histFile.toFile().length() > 0, "history file should not be empty"); + } + + @Test + void close_doesNotThrow() throws IOException { + var rl = readingFrom(""); + assertDoesNotThrow(rl::close); + } +} diff --git a/use-core/src/test/java/org/tzi/use/util/input/LineInputTest.java b/use-core/src/test/java/org/tzi/use/util/input/LineInputTest.java new file mode 100644 index 000000000..25991794e --- /dev/null +++ b/use-core/src/test/java/org/tzi/use/util/input/LineInputTest.java @@ -0,0 +1,70 @@ +/* + * USE - UML based specification environment + * Copyright (C) 1999-2004 Mark Richters, University of Bremen + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +package org.tzi.use.util.input; + +import org.junit.jupiter.api.Test; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.StringReader; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Characterization (safety-net) tests for the {@link LineInput} factory. + * + *These cover the stable {@code getStreamReadline} factory method whose + * behaviour must be preserved across the migration to JLine.
+ */ +class LineInputTest { + + @Test + void getStreamReadline_returnsReadlineThatReadsTheStream() throws IOException { + BufferedReader reader = new BufferedReader(new StringReader("test line\n")); + try (Readline rl = LineInput.getStreamReadline(reader, false, "")) { + assertEquals("test line", rl.readline("> ")); + } + } + + @Test + void getStreamReadline_withoutEcho_doEchoIsFalse() { + BufferedReader reader = new BufferedReader(new StringReader("")); + Readline rl = LineInput.getStreamReadline(reader, false, ""); + assertFalse(rl.doEcho()); + } + + @Test + void getStreamReadline_withEcho_doEchoIsTrue() { + BufferedReader reader = new BufferedReader(new StringReader("")); + Readline rl = LineInput.getStreamReadline(reader, true, ""); + assertTrue(rl.doEcho()); + } + + @Test + void getUserInputReadline_returnsNonNullNonEchoingReadline() { + // The interactive factory must always yield a usable, non-echoing + // Readline. Whether that is a JLineReadline (interactive terminal) + // or the StreamReadline fallback (headless/piped) depends on the + // environment, but the behavioural contract is the same. + Readline rl = LineInput.getUserInputReadline(); + assertNotNull(rl); + assertFalse(rl.doEcho()); + } +} diff --git a/use-core/src/test/java/org/tzi/use/util/input/StreamReadlineTest.java b/use-core/src/test/java/org/tzi/use/util/input/StreamReadlineTest.java new file mode 100644 index 000000000..04b1c2359 --- /dev/null +++ b/use-core/src/test/java/org/tzi/use/util/input/StreamReadlineTest.java @@ -0,0 +1,100 @@ +/* + * USE - UML based specification environment + * Copyright (C) 1999-2004 Mark Richters, University of Bremen + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +package org.tzi.use.util.input; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.StringReader; +import java.nio.file.Path; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Characterization (safety-net) tests for {@link StreamReadline} — the + * fallback {@link Readline} implementation used when no interactive terminal + * is available. + * + *These tests pin down the behaviour of the existing implementation so we + * can be confident the migration from native GNU readline to JLine does not + * change the contract every {@link Readline} must satisfy.
+ */ +class StreamReadlineTest { + + private static StreamReadline from(String input) { + return new StreamReadline(new BufferedReader(new StringReader(input)), false); + } + + @Test + void readline_returnsInputLineWithoutLineTerminator() throws IOException { + try (var rl = from("hello\n")) { + assertEquals("hello", rl.readline("prompt> ")); + } + } + + @Test + void readline_returnsNullAtEndOfStream() throws IOException { + try (var rl = from("")) { + assertNull(rl.readline("prompt> ")); + } + } + + @Test + void readline_handlesMultipleLinesThenEof() throws IOException { + try (var rl = from("first\nsecond\n")) { + assertEquals("first", rl.readline("> ")); + assertEquals("second", rl.readline("> ")); + assertNull(rl.readline("> ")); + } + } + + @Test + void doEcho_isFalseByDefault() { + assertFalse(from("").doEcho()); + } + + @Test + void doEcho_isTrueWhenConstructedWithEcho() { + var rl = new StreamReadline(new BufferedReader(new StringReader("")), true); + assertTrue(rl.doEcho()); + } + + @Test + void usingHistory_isANoOp() { + assertDoesNotThrow(() -> from("").usingHistory()); + } + + @Test + void readHistory_isANoOp(@TempDir Path tmp) { + assertDoesNotThrow(() -> from("").readHistory(tmp.resolve("history").toString())); + } + + @Test + void writeHistory_isANoOp(@TempDir Path tmp) { + assertDoesNotThrow(() -> from("").writeHistory(tmp.resolve("history").toString())); + } + + @Test + void close_doesNotThrow() { + assertDoesNotThrow(() -> from("").close()); + } +} diff --git a/use-gui/src/main/java/org/tzi/use/main/shell/Shell.java b/use-gui/src/main/java/org/tzi/use/main/shell/Shell.java index ce5c49d93..4afcdfb4c 100644 --- a/use-gui/src/main/java/org/tzi/use/main/shell/Shell.java +++ b/use-gui/src/main/java/org/tzi/use/main/shell/Shell.java @@ -268,18 +268,7 @@ private void setupReadline() { return; } - String GNUReadlineNotAvailable; - if (Options.suppressWarningsAboutMissingReadlineLibrary) { - GNUReadlineNotAvailable = null; - } else { - GNUReadlineNotAvailable = "Apparently, the GNU readline library is not available on your system." - + Options.LINE_SEPARATOR - + "The program will continue using a simple readline implementation." - + Options.LINE_SEPARATOR - + "You can turn off this warning message by using the switch -nr"; - } - - fReadline = LineInput.getUserInputReadline(GNUReadlineNotAvailable); + fReadline = LineInput.getUserInputReadline(); fReadline.usingHistory(); // Read command history from previous sessions diff --git a/use-gui/src/main/resources/bin/start_use.bat b/use-gui/src/main/resources/bin/start_use.bat index 3b07f5c16..30c7131ad 100644 --- a/use-gui/src/main/resources/bin/start_use.bat +++ b/use-gui/src/main/resources/bin/start_use.bat @@ -21,9 +21,9 @@ IF NOT EXIST %USE_JAR% ( REM Check if first argument is "jfx" (/I makes the comparison case-insensitive) IF /I "%1"=="-jfx" ( - java %VMARGS% --module-path %JAVAFX_LIB% --add-modules javafx.controls,javafx.fxml,javafx.web,javafx.graphics,javafx.swing --add-opens javafx.graphics/com.sun.javafx.scene=ALL-UNNAMED --add-exports javafx.base/com.sun.javafx.event=ALL-UNNAMED -jar %USE_JAR% -nr %* + java %VMARGS% --module-path %JAVAFX_LIB% --add-modules javafx.controls,javafx.fxml,javafx.web,javafx.graphics,javafx.swing --add-opens javafx.graphics/com.sun.javafx.scene=ALL-UNNAMED --add-exports javafx.base/com.sun.javafx.event=ALL-UNNAMED -jar %USE_JAR% %* ) ELSE ( - java %VMARGS% -jar %USE_JAR% -nr %* + java %VMARGS% -jar %USE_JAR% %* ) if "%OS%"=="Windows_NT" @endlocal diff --git a/use-gui/src/main/resources/bin/use b/use-gui/src/main/resources/bin/use index ce8c0b78b..cde6bb5e1 100755 --- a/use-gui/src/main/resources/bin/use +++ b/use-gui/src/main/resources/bin/use @@ -16,7 +16,5 @@ if [ ! -f "$USE_JAR" ]; then exit 1 fi -export LD_LIBRARY_PATH="$USE_HOME/lib:$LD_LIBRARY_PATH" - # set cmd for running USE java $VMARGS -jar "$USE_JAR" "$@"