ScriptInterpreter: allow multi-line evaluation

This adds new methods designed to support evaluation of multi-line
statements which are fed to the interpreter one line at a time. The
approach works according to a strategy implemented by Jason Sachs on
StackOverflow at:

    http://stackoverflow.com/a/5598207

This functionality will be useful for improving the behavior of
REPL (Read-Eval-Print-Loop) shells backed by this interpreter.

Author: ctrueden

src/main/java/org/scijava/script/DefaultScriptInterpreter.java

@@ -30,17 +30,28 @@
  */
 package org.scijava.script;
 
+import java.lang.reflect.Method;
+
 import javax.script.Bindings;
+import javax.script.Compilable;
+import javax.script.CompiledScript;
 import javax.script.ScriptContext;
 import javax.script.ScriptEngine;
 import javax.script.ScriptException;
 
+import org.scijava.log.LogService;
+import org.scijava.plugin.Parameter;
 import org.scijava.prefs.PrefService;
 
 /**
  * The default implementation of a {@link ScriptInterpreter}.
+ * <p>
+ * Credit to Jason Sachs for the multi-line evaluation (see
+ * <a href="http://stackoverflow.com/a/5598207">his post on StackOverflow</a>).
+ * </p>
  *  
  * @author Johannes Schindelin
+ * @author Curtis Rueden
  */
 public class DefaultScriptInterpreter implements ScriptInterpreter {
 
@@ -51,6 +62,13 @@ public class DefaultScriptInterpreter implements ScriptInterpreter {
 	@Parameter(required = false)
 	private PrefService prefs;
 
+	@Parameter(required = false)
+	private LogService log;
+
+	private final StringBuilder buffer;
+	private int pendingLineCount;
+	private boolean expectingMoreInput;
+
 	/**
 	 * @deprecated Use {@link #DefaultScriptInterpreter(ScriptLanguage)} instead.
 	 */
@@ -88,6 +106,8 @@ public DefaultScriptInterpreter(final ScriptLanguage language,
 		history = prefs == null ? null :
 			new History(prefs, this.engine.getClass().getName());
 		readHistory();
+		buffer = new StringBuilder();
+		reset();
 	}
 
 	// -- ScriptInterpreter methods --
@@ -115,11 +135,101 @@ public synchronized String walkHistory(final String currentCommand,
 
 	@Override
 	public Object eval(final String command) throws ScriptException {
-		if (history != null) history.add(command);
-		if (engine == null) throw new java.lang.IllegalArgumentException();
+		addToHistory(command);
 		return engine.eval(command);
 	}
 
+	/**
+	 * {@inheritDoc}
+	 * <p>
+	 * This implementation from Jason Sachs uses the following strategy:
+	 * </p>
+	 * <ul>
+	 * <li>Keep a pending list of input lines not yet evaluated.</li>
+	 * <li>Try compiling (but not evaluating) the pending input lines.
+	 * <ul>
+	 * <li>If the compilation is OK, we may be able to execute pending input
+	 * lines.</li>
+	 * <li>If the compilation throws an exception, and there is an indication of
+	 * the position (line + column number) of the error, and this matches the end
+	 * of the pending input, then that's a clue that we're expecting more input,
+	 * so swallow the exception and wait for the next line.</li>
+	 * <li>Otherwise, we either don't know where the error is, or it happened
+	 * prior to the end of the pending input, so rethrow the exception.</li>
+	 * </ul>
+	 * </li>
+	 * <li>If we are not expecting any more input lines, and we only have one line
+	 * of pending input, then evaluate it and restart.</li>
+	 * <li>If we are not expecting any more input lines, and the last one is a
+	 * blank one, and we have more than one line of pending input, then evaluate
+	 * it and restart. Python's interactive shell seems to do this.</li>
+	 * <li>Otherwise, keep reading input lines.</li>
+	 * </ul>
+	 * <p>
+	 * This helps avoid certain problems:
+	 * </p>
+	 * <ul>
+	 * <li>users getting annoyed having to enter extra blank lines after
+	 * single-line inputs</li>
+	 * <li>users entering a long multi-line statement and only find out after the
+	 * fact that there was a syntax error in the 2nd line.</li>
+	 * </ul>
+	 * <p>
+	 * For further details, see <a href="http://stackoverflow.com/a/5598207">SO
+	 * #5584674</a>.
+	 * </p>
+	 * </p>
+	 */
+	@Override
+	public Object interpret(final String line) throws ScriptException {
+		if (line.isEmpty()) {
+			if (!shouldEvaluatePendingInput(true)) return MORE_INPUT_PENDING;
+		}
+
+		pendingLineCount++;
+		buffer.append(line);
+		buffer.append("\n");
+
+		if (!(engine instanceof Compilable)) {
+			// Not a compilable language.
+			// Evaluate directly, with no multi-line statements possible.
+			try {
+				return eval(buffer.toString());
+			}
+			finally {
+				reset();
+			}
+		}
+
+		final CompiledScript cs = tryCompiling(buffer.toString(),
+			getPendingLineCount(), line.length());
+
+		if (cs == null) {
+			// Command did not compile.
+			// Assume it is incomplete and wait for more input on the next line.
+			return MORE_INPUT_PENDING;
+		}
+		if (!shouldEvaluatePendingInput(line.isEmpty())) {
+			// We are still expecting more input.
+			return MORE_INPUT_PENDING;
+		}
+		// Command is complete; evaluate the compiled script.
+		try {
+			addToHistory(buffer.toString());
+			return cs.eval();
+		}
+		finally {
+			reset();
+		}
+	}
+
+	@Override
+	public void reset() {
+		buffer.setLength(0);
+		pendingLineCount = 0;
+		expectingMoreInput = false;
+	}
+
 	@Override
 	public ScriptLanguage getLanguage() {
 		return language;
@@ -135,4 +245,122 @@ public Bindings getBindings() {
 		return engine.getBindings(ScriptContext.ENGINE_SCOPE);
 	}
 
+	@Override
+	public boolean isReady() {
+		return buffer.length() == 0;
+	}
+
+	@Override
+	public boolean isExpectingMoreInput() {
+		return expectingMoreInput;
+	}
+
+	// -- Helper methods --
+
+	private void addToHistory(final String command) {
+		if (history != null) history.add(command);
+	}
+
+	/**
+	 * @return number of lines pending execution
+	 */
+	private int getPendingLineCount() {
+		return pendingLineCount;
+	}
+
+	/**
+	 * @param lineIsEmpty whether the last line is empty
+	 * @return whether we should evaluate the pending input. The default behavior
+	 *         is to evaluate if we only have one line of input, or if the user
+	 *         enters a blank line. This behavior should be overridden where
+	 *         appropriate.
+	 */
+	private boolean shouldEvaluatePendingInput(final boolean lineIsEmpty) {
+		if (isExpectingMoreInput()) return false;
+		return getPendingLineCount() == 1 || lineIsEmpty;
+	}
+
+	private CompiledScript tryCompiling(final String string, final int lineCount,
+		final int lastLineLength) throws ScriptException
+	{
+		CompiledScript result = null;
+		try {
+			final Compilable c = (Compilable) engine;
+			result = c.compile(string);
+		}
+		catch (final ScriptException se) {
+			boolean rethrow = true;
+			if (se.getCause() != null) {
+				final Integer col = columnNumber(se);
+				final Integer line = lineNumber(se);
+				// swallow the exception if it occurs at the last character
+				// of the input (we may need to wait for more lines)
+				if (isLastCharacter(col, line, lineCount, lastLineLength)) {
+					rethrow = false;
+				}
+				else if (log != null && log.isDebug()) {
+					final String msg = se.getCause().getMessage();
+					log.debug("L" + line + " C" + col + "(" + lineCount + "," +
+						lastLineLength + "): " + msg);
+					log.debug("in '" + string + "'");
+				}
+			}
+
+			if (rethrow) {
+				reset();
+				throw se;
+			}
+		}
+
+		expectingMoreInput = result == null;
+		return result;
+	}
+
+	private boolean isLastCharacter(final Integer col, final Integer line,
+		final int lineCount, final int lastLineLength)
+	{
+		if (col == null || line == null) return false;
+		final int colNo = col.intValue(), lineNo = line.intValue();
+		return lineNo == lineCount && colNo == lastLineLength ||
+			lineNo == lineCount + 1 && colNo == 0;
+	}
+
+	private Integer columnNumber(final ScriptException se) {
+		if (se.getColumnNumber() >= 0) return se.getColumnNumber();
+		return callMethod(se.getCause(), "columnNumber", Integer.class);
+	}
+
+	private Integer lineNumber(final ScriptException se) {
+		if (se.getLineNumber() >= 0) return se.getLineNumber();
+		return callMethod(se.getCause(), "lineNumber", Integer.class);
+	}
+
+	private static Method getMethod(final Object object,
+		final String methodName)
+	{
+		try {
+			return object.getClass().getMethod(methodName);
+		}
+		catch (final NoSuchMethodException e) {
+			// gulp
+			return null;
+		}
+	}
+
+	private static <T> T callMethod(final Object object, final String methodName,
+		final Class<T> cl)
+	{
+		try {
+			final Method m = getMethod(object, methodName);
+			if (m != null) {
+				final Object result = m.invoke(object);
+				return cl.cast(result);
+			}
+		}
+		catch (final Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+
 }

src/main/java/org/scijava/script/ScriptInterpreter.java

@@ -40,9 +40,16 @@
  * The contract for script interpreters.
  * 
  * @author Johannes Schindelin
+ * @author Curtis Rueden
  */
 public interface ScriptInterpreter {
 
+	/**
+	 * A special object returned by {@link #interpret(String)} when the
+	 * interpreter is expecting additional input before finishing the evaluation.
+	 */
+	Object MORE_INPUT_PENDING = new Object();
+
 	/**
 	 * Reads the persisted history of the current script interpreter.
 	 */
@@ -72,6 +79,26 @@ public interface ScriptInterpreter {
 	 */
 	Object eval(String command) throws ScriptException;
 
+	/**
+	 * Interprets the given line of code, which might be part of a multi-line
+	 * statement.
+	 * 
+	 * @param line line of code to interpret
+	 * @return value of the line, or {@link #MORE_INPUT_PENDING} if there is still
+	 *         pending input
+	 * @throws ScriptException in case of an exception
+	 */
+	Object interpret(String line) throws ScriptException;
+
+	/**
+	 * Clears the buffer of not-yet-evaluated lines of code, accumulated from
+	 * previous calls to {@link #interpret}. In other words: start over with a new
+	 * (potentially multi-line) statement, discarding the current partial one.
+	 * 
+	 * @see #interpret
+	 */
+	void reset();
+
 	/**
 	 * Returns the associated {@link ScriptLanguage}.
 	 */
@@ -90,4 +117,20 @@ public interface ScriptInterpreter {
 	 */
 	Bindings getBindings();
 
+	/**
+	 * @return whether the interpreter is ready for a brand new statement.
+	 * @see #interpret(String)
+	 */
+	boolean isReady();
+
+	/**
+	 * @return whether the interpreter expects more input. A true value means
+	 *         there is definitely more input needed. A false value means no more
+	 *         input is needed, but it may not yet be appropriate to evaluate all
+	 *         the pending lines. (there's some ambiguity depending on the
+	 *         language)
+	 * @see #interpret(String)
+	 */
+	boolean isExpectingMoreInput();
+
 }