use readline module for history and completion

timfel · timfel · commit 02aa28f739cc · 2018-10-18T09:32:31.000+02:00
diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/ConsoleHandler.java
@@ -43,6 +43,11 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
 
 import org.graalvm.polyglot.Context;
 
@@ -59,10 +64,19 @@ public abstract class ConsoleHandler {
 
     public abstract void setPrompt(String prompt);
 
+    public void addCompleter(@SuppressWarnings("unused") Function<String, List<String>> completer) {
+        // ignore by default
+    }
+
     public void setContext(@SuppressWarnings("unused") Context context) {
         // ignore by default
     }
 
+    @SuppressWarnings("unused")
+    public void setHistory(Supplier<Integer> getSize, Consumer<String> addItem, Function<Integer, String> getItem, BiConsumer<Integer, String> setItem, Consumer<Integer> removeItem, Runnable clear) {
+        // ignore by default
+    }
+
     public InputStream createInputStream() {
         return new InputStream() {
             byte[] buffer = null;
diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/GraalPythonMain.java
@@ -48,6 +48,7 @@
 import org.graalvm.polyglot.PolyglotException.StackFrame;
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.SourceSection;
+import org.graalvm.polyglot.Value;
 
 import jline.console.UserInterruptException;
 
@@ -517,9 +518,12 @@ public ConsoleHandler createConsoleHandler(InputStream inStream, OutputStream ou
     public int readEvalPrint(Context context, ConsoleHandler consoleHandler) {
         int lastStatus = 0;
         try {
+            setupReadline(context, consoleHandler);
+
             while (true) { // processing inputs
                 boolean doEcho = doEcho(context);
                 consoleHandler.setPrompt(doEcho ? getPrompt(context) : null);
+
                 try {
                     String input = consoleHandler.readLine();
                     if (input == null) {
@@ -588,6 +592,36 @@ public int readEvalPrint(Context context, ConsoleHandler consoleHandler) {
         }
     }
 
+    private void setupReadline(Context context, ConsoleHandler consoleHandler) {
+        final Value readline = context.eval(Source.newBuilder(getLanguageId(), "import readline; readline", "setup-interactive").interactive(true).buildLiteral());
+        final Value completer = readline.getMember("get_completer").execute();
+        final Value addHistory = readline.getMember("add_history");
+        final Value getHistoryItem = readline.getMember("get_history_item");
+        final Value setHistoryItem = readline.getMember("replace_history_item");
+        final Value deleteHistoryItem = readline.getMember("remove_history_item");
+        final Value clearHistory = readline.getMember("clear_history");
+        final Value getHistorySize = readline.getMember("get_current_history_length");
+        consoleHandler.setHistory(
+                        () -> getHistorySize.execute().asInt(),
+                        (item) -> addHistory.execute(item),
+                        (pos) -> getHistoryItem.execute(pos).asString(),
+                        (pos, item) -> setHistoryItem.execute(pos, item),
+                        (pos) -> deleteHistoryItem.execute(pos),
+                        () -> clearHistory.execute());
+
+        if (completer.canExecute()) {
+            consoleHandler.addCompleter((buffer) -> {
+                List<String> candidates = new ArrayList<>();
+                Value candidate = completer.execute(buffer, candidates.size());
+                while (candidate.isString()) {
+                    candidates.add(candidate.asString());
+                    candidate = completer.execute(buffer, candidates.size());
+                }
+                return candidates;
+            });
+        }
+    }
+
     private static final class ExitException extends RuntimeException {
         private static final long serialVersionUID = 1L;
         private final int code;
diff --git a/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java b/graalpython/com.oracle.graal.python.shell/src/com/oracle/graal/python/shell/JLineConsoleHandler.java
@@ -40,16 +40,26 @@
  */
 package com.oracle.graal.python.shell;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import org.graalvm.polyglot.Context;
+
 import jline.console.ConsoleReader;
 import jline.console.UserInterruptException;
 import jline.console.completer.CandidateListCompletionHandler;
+import jline.console.completer.Completer;
 import jline.console.completer.CompletionHandler;
+import jline.console.history.History;
 import jline.console.history.MemoryHistory;
-import org.graalvm.polyglot.Context;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
 
 public class JLineConsoleHandler extends ConsoleHandler {
     private final ConsoleReader console;
@@ -64,12 +74,154 @@ public JLineConsoleHandler(InputStream inStream, OutputStream outStream, boolean
             console.setHistory(history);
             console.setHandleUserInterrupt(true);
             console.setExpandEvents(false);
+            console.setCommentBegin("#");
         } catch (IOException ex) {
             // TODO throw proper exception type
             throw new RuntimeException("unexpected error opening console reader", ex);
         }
     }
 
+    @Override
+    public void addCompleter(Function<String, List<String>> completer) {
+        console.addCompleter(new Completer() {
+            public int complete(String buffer, int cursor, List<CharSequence> candidates) {
+                if (buffer != null) {
+                    candidates.addAll(completer.apply(buffer));
+                }
+                return candidates.isEmpty() ? -1 : 0;
+            }
+        });
+
+    }
+
+    @Override
+    public void setHistory(Supplier<Integer> getSize, Consumer<String> addItem, Function<Integer, String> getItem, BiConsumer<Integer, String> setItem, Consumer<Integer> removeItem, Runnable clear) {
+        console.setHistory(new History() {
+            private int pos = getSize.get();
+
+            public int size() {
+                return getSize.get();
+            }
+
+            public void set(int arg0, CharSequence arg1) {
+                setItem.accept(arg0, arg1.toString());
+            }
+
+            public void replace(CharSequence arg0) {
+                if (pos < 0 || pos >= size()) {
+                    return;
+                }
+                setItem.accept(pos, arg0.toString());
+            }
+
+            public CharSequence removeLast() {
+                int t = size() - 1;
+                String s = getItem.apply(t);
+                removeItem.accept(t);
+                return s;
+            }
+
+            public CharSequence removeFirst() {
+                int t = size() - 1;
+                String s = getItem.apply(t);
+                removeItem.accept(0);
+                return s;
+            }
+
+            public CharSequence remove(int arg0) {
+                int t = size() - 1;
+                String s = getItem.apply(t);
+                removeItem.accept(arg0);
+                return s;
+            }
+
+            public boolean previous() {
+                if (pos >= 0) {
+                    pos--;
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            public boolean next() {
+                if (pos < size()) {
+                    pos++;
+                    return true;
+                } else {
+                    return false;
+                }
+            }
+
+            public boolean moveToLast() {
+                pos = size();
+                return true;
+            }
+
+            public boolean moveToFirst() {
+                pos = 0;
+                return true;
+            }
+
+            public void moveToEnd() {
+                moveToLast();
+            }
+
+            public boolean moveTo(int arg0) {
+                pos = arg0;
+                int size = size();
+                if (pos < 0 || pos >= size) {
+                    pos = pos % size;
+                    return false;
+                }
+                return true;
+            }
+
+            public Iterator<Entry> iterator() {
+                // TODO Auto-generated method stub
+                return null;
+            }
+
+            public boolean isEmpty() {
+                return size() == 0;
+            }
+
+            public int index() {
+                return pos;
+            }
+
+            public CharSequence get(int arg0) {
+                return getItem.apply(arg0);
+            }
+
+            public ListIterator<Entry> entries(int arg0) {
+                // TODO Auto-generated method stub
+                return null;
+            }
+
+            public ListIterator<Entry> entries() {
+                // TODO Auto-generated method stub
+                return null;
+            }
+
+            public CharSequence current() {
+                if (pos < 0 || pos >= size()) {
+                    return "";
+                }
+                return getItem.apply(pos);
+            }
+
+            public void clear() {
+                clear.run();
+            }
+
+            public void add(CharSequence arg0) {
+                addItem.accept(arg0.toString());
+                pos = size();
+            }
+        });
+    }
+
     @Override
     public void setContext(Context context) {
         CompletionHandler completionHandler = console.getCompletionHandler();
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ReadlineModuleBuiltins.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/modules/ReadlineModuleBuiltins.java
@@ -59,6 +59,7 @@
 import com.oracle.graal.python.nodes.function.PythonBuiltinBaseNode;
 import com.oracle.graal.python.nodes.function.PythonBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonBinaryBuiltinNode;
+import com.oracle.graal.python.nodes.function.builtins.PythonTernaryBuiltinNode;
 import com.oracle.graal.python.nodes.function.builtins.PythonUnaryBuiltinNode;
 import com.oracle.graal.python.runtime.PythonCore;
 import com.oracle.graal.python.runtime.exception.PythonErrorType;
@@ -161,6 +162,79 @@ int setCompleter(PythonModule self,
         }
     }
 
+    @Builtin(name = "get_history_item", fixedNumOfPositionalArgs = 2, declaresExplicitSelf = true)
+    @GenerateNodeFactory
+    abstract static class SetHistoryLengthNode extends PythonBinaryBuiltinNode {
+        @Specialization
+        @TruffleBoundary
+        String setCompleter(PythonModule self, int index,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            LocalData data = (LocalData) readNode.execute(self, DATA);
+            try {
+                return data.history.get(index);
+            } catch (IndexOutOfBoundsException e) {
+                throw raise(PythonErrorType.IndexError, "index out of bounds");
+            }
+        }
+    }
+
+    @Builtin(name = "replace_history_item", fixedNumOfPositionalArgs = 3, declaresExplicitSelf = true)
+    @GenerateNodeFactory
+    abstract static class ReplaceItemNode extends PythonTernaryBuiltinNode {
+        @Specialization
+        String setCompleter(PythonModule self, int index, PString string,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            return setCompleter(self, index, string.getValue(), readNode);
+        }
+
+        @Specialization
+        @TruffleBoundary
+        String setCompleter(PythonModule self, int index, String string,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            LocalData data = (LocalData) readNode.execute(self, DATA);
+            try {
+                return data.history.set(index, string);
+            } catch (IndexOutOfBoundsException e) {
+                throw raise(PythonErrorType.IndexError, "index out of bounds");
+            }
+        }
+    }
+
+    @Builtin(name = "remove_history_item", fixedNumOfPositionalArgs = 2, declaresExplicitSelf = true)
+    @GenerateNodeFactory
+    abstract static class DeleteItemNode extends PythonBinaryBuiltinNode {
+        @Specialization
+        @TruffleBoundary
+        String setCompleter(PythonModule self, int index,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            LocalData data = (LocalData) readNode.execute(self, DATA);
+            try {
+                return data.history.remove(index);
+            } catch (IndexOutOfBoundsException e) {
+                throw raise(PythonErrorType.IndexError, "index out of bounds");
+            }
+        }
+    }
+
+    @Builtin(name = "add_history", fixedNumOfPositionalArgs = 2, declaresExplicitSelf = true)
+    @GenerateNodeFactory
+    abstract static class AddHistoryNode extends PythonBinaryBuiltinNode {
+        @Specialization
+        PNone addHistory(PythonModule self, PString item,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            return addHistory(self, item.getValue(), readNode);
+        }
+
+        @Specialization
+        @TruffleBoundary
+        PNone addHistory(PythonModule self, String item,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            LocalData data = (LocalData) readNode.execute(self, DATA);
+            data.history.add(item);
+            return PNone.NONE;
+        }
+    }
+
     @Builtin(name = "read_history_file", fixedNumOfPositionalArgs = 2, declaresExplicitSelf = true)
     @GenerateNodeFactory
     abstract static class ReadHistoryFileNode extends PythonBinaryBuiltinNode {
@@ -181,6 +255,7 @@ PNone setCompleter(PythonModule self, String path,
                 while ((line = reader.readLine()) != null) {
                     data.history.add(line);
                 }
+                reader.close();
             } catch (IOException e) {
                 throw raise(PythonErrorType.IOError, e.getMessage());
             }
@@ -208,13 +283,26 @@ PNone setCompleter(PythonModule self, String path,
                     writer.write(l);
                     writer.newLine();
                 }
+                writer.close();
             } catch (IOException e) {
                 throw raise(PythonErrorType.IOError, e.getMessage());
             }
             return PNone.NONE;
         }
     }
 
+    @Builtin(name = "clear_history", fixedNumOfPositionalArgs = 1, declaresExplicitSelf = true)
+    @GenerateNodeFactory
+    abstract static class ClearNode extends PythonUnaryBuiltinNode {
+        @Specialization
+        PNone setCompleter(PythonModule self,
+                        @Cached("create()") ReadAttributeFromObjectNode readNode) {
+            LocalData data = (LocalData) readNode.execute(self, DATA);
+            data.history.clear();
+            return PNone.NONE;
+        }
+    }
+
     @Builtin(name = "insert_text", fixedNumOfPositionalArgs = 1)
     @GenerateNodeFactory
     abstract static class InsertTextNode extends PythonUnaryBuiltinNode {
