WIP - add socket repl plugin

Author: jebberjeb

TODO

@@ -0,0 +1,42 @@
+TODO
+	[X] Make buffer-get-text-async work, just test it at the repl
+	[X] Get "eval-code" working
+	[_] Figure out how to accumulate / display results in vim
+	[_] Name vim functions correctly
+	[_] Pass host, port in connect
+
+Goals
+	-Zero vimscript (plugin written in clojure)
+	-Simplicity
+		Ex:
+			Don't modify behavior of stdio, stacktrace printing
+			Append results to a "repl" buffer
+		Code
+			No nrepl (no request / response)
+			No middleware
+			No vimscript
+			Clojure-only plugin
+			All results displayed in one place
+			One connection
+	-Run repl side-by-side with editor
+		Does not automatically start a repl
+		Forces you to explicity connect
+		One connection only `:call ConnectClojurePlugin(host, port)`
+		Accessible from vim buffer `:call ShowClojurePluginRepl()`
+
+Questions
+	Figwheel cljs-repl support
+
+Usage
+	add command line args to your project, so it starts socket repl
+	tell the plugin port (and host) to connect to
+
+Debugging notes
+	vim
+		rpcrequest(1, ...) <-- use channel 1, w/ tcp
+		don't do rpcstart
+	clj
+		connect! add localhost 7777
+		vim blocks if you make a synchronous call to clj which makes a sync
+		call back to vim -- use async!
+

plugin/socketrepl.vim

@@ -0,0 +1,34 @@
+let s:p_dir = expand('<sfile>:p:h')
+let g:is_running = 0
+let g:channel = -1
+
+function! StartIfNotRunning()
+    if g:is_running == 0
+        echo 'starting plugin...'
+        "TODO - This is a dirty hack. We should launch things without changing
+        "the working directory.
+        exec ':cd ' . s:p_dir
+        let g:channel = rpcstart('lein', ['run'])
+        let g:is_running = 1
+    endif
+endfunction
+
+function! EvalConnect()
+    "call StartIfNotRunning()
+    let res = rpcrequest(1, 'connect', [])
+    return res
+endfunction
+
+function! EvalBuffer()
+    "call StartIfNotRunning()
+    let res = rpcrequest(1, 'eval-buffer', [])
+    return res
+endfunction
+
+function! EvalCode()
+    "call StartIfNotRunning()
+    let res = rpcrequest(g:channel, 'eval-code', [])
+    return res
+endfunction
+
+echo 'socket repl plugin loaded!'

project.clj

@@ -3,11 +3,16 @@
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.6.0"]
+  :dependencies [[org.clojure/clojure "1.9.0-alpha12"]
                  [org.clojure/core.async "0.1.346.0-17112a-alpha"]
+                 ;; TODO: upgrade to this
+                 ;; [org.clojure/core.async "0.2.391"]
                  [org.clojure/tools.logging "0.3.1"]
                  [clj-logging-config "1.9.12"]
                  [clojure-msgpack "1.0.0"]]
   :repl-options {:init-ns neovim-client.nvim}
+  ;; TODO: remove this
+  ;;:jvm-opts ["-Dclojure.server.repl={:port 5555 :accept clojure.core.server/repl}"]
+  :main ^:skip-aot neovim-client.socket-repl-plugin
   :target-path "target/%s"
   :profiles {:uberjar {:aot :all}})

src/neovim_client/nvim.clj

@@ -1,6 +1,6 @@
 (ns neovim-client.nvim
   (:require [clojure.string :as str]
-            [neovim-client.message :refer [->request-msg]]
+            [neovim-client.message :as message :refer [->request-msg]]
             [neovim-client.rpc :as rpc]))
 
 ;; ***** Public *****
@@ -26,11 +26,27 @@
 
 (defn set-current-line!  [line] (send-message! "vim_set_current_line" line))
 
-(defn get-current-buffer [] (send-message! "vim_get_current_buffer"))
+(defn get-current-buffer
+  ;; TODO: fix comment
+  "Returns ??? (object, map, ?) representing the current buffer."
+  []
+  (send-message! "vim_get_current_buffer"))
+
+(declare buffer-get-text)
+(defn get-current-buffer-async
+  "Like `get-current-buffer`, but async."
+  [f]
+  (rpc/send-message-async! (->request-msg "vim_get_current_buffer" []) f))
 
 (defn get-buffers [] (send-message! "vim_get_buffers"))
 
 (defn get-buffer-line-count [buffer] (send-message! "buffer_line_count" buffer))
+(defn get-buffer-line-count-async
+  "Like `get-buffer-line-count but async.
+
+  `f` callback function invoked with the buffer line count as an argument."
+  [buffer f]
+  (rpc/send-message-async! (->request-msg "buffer_line_count" [buffer]) f))
 
 (defn buffer-set-line!
   [buffer line-num line]
@@ -52,6 +68,11 @@
   (rpc/send-message-async! (->request-msg "buffer_get_line"
                                           [buffer line-num]) f))
 
+(defn buffer-get-lines-async
+  [buffer start end f]
+  (rpc/send-message-async! (->request-msg "buffer_get_line_slice"
+                                          [buffer start end true true]) f))
+
 ;; ***** Experimental *****
 
 (defn buffer-update-lines!
@@ -68,6 +89,12 @@
         lines (map (partial buffer-get-line buffer) (range buf-size))]
     (str/join "\n" lines)))
 
+(defn get-current-buffer-text-async
+  "Convenience function to get the current buffer's text asynchronously."
+  [f]
+  (get-current-buffer-async
+    (fn [buffer] (buffer-get-lines-async buffer 0 -1 f))))
+
 ;; TODO - make it wipe out text in the buffer after the last line of new text.
 (defn buffer-set-text!
   [buffer text]

src/neovim_client/socket_repl_plugin.clj

@@ -0,0 +1,96 @@
+(ns neovim-client.socket-repl-plugin
+  "A plugin which connects to a running socket repl and sends output back to
+  Neovim."
+  (:require
+    [clojure.java.io :as io]
+    [clojure.core.async :as async :refer [go go-loop >! <!]]
+    [neovim-client.nvim :as nvim])
+  (:import
+    (java.net Socket)
+    (java.io PrintStream)))
+
+(defn connection
+  [host port]
+  (let [socket (java.net.Socket. "localhost" 5555)]
+    {:host host
+     :port port
+     :out (-> socket
+              io/output-stream
+              PrintStream.)
+     :in (io/reader socket)}))
+
+(defn eval*
+  [{:keys [:out]} code-string]
+  (.println out code-string)
+  (.flush out))
+
+(def current-connection (atom nil))
+
+(defn connect!
+  [host port handler]
+  (let [conn (connection host port)
+        chan (async/chan 10)]
+    (reset! current-connection (assoc conn
+                                      :handler handler
+                                      :chan chan))
+
+    ;; input producer
+    (go-loop []
+             (when-let [line (.readLine (:in conn))]
+               (>! chan line)
+               (recur)))
+
+    ;; input consumer
+    (go-loop []
+             (when-let [x (<! chan)]
+               (handler x)
+               (recur))))
+  "success")
+
+(defn eval*!
+  [code-string]
+  (eval* @current-connection code-string))
+
+(defn -main
+  [& args]
+  ;; TODO: remove params for STDIO
+  (nvim/connect! "localhost" 7777)
+
+  (nvim/register-method!
+    "connect"
+    (fn [msg]
+      ;; TODO: Get host/port from message
+      (connect! "localhost" "5555"
+                (fn [x]
+                  (nvim/run-command-async!
+                    ;; TODO: Actually, append to a buffer?
+                    (format ":echo '%s'" (pr-str x))
+                    (fn [_] nil))))))
+
+   (nvim/register-method!
+     "eval-code"
+     (fn [msg]
+       ;; TODO: Get the cursor location, find current form
+       ))
+
+   (nvim/register-method!
+     "eval-buffer"
+     (fn [msg]
+       (nvim/get-current-buffer-text-async
+         (fn [[x & _]]
+           ;; TODO: send code being executed
+           ;; back to vim, to show what actually
+           ;; happened in the repl buffer
+           (eval*! x)))))
+
+  ;; TODO: When do we disconnect?
+  (comment
+    (dotimes [n 60]
+      (if (= 0 (mod n 10))
+        (nvim/run-command! (str ":echo 'plugin alive for " n " seconds.'")))
+      (Thread/sleep 1000))
+
+    ;; Let nvim know we're shutting down.
+    (nvim/run-command! ":let g:is_running=0")
+    (nvim/run-command! ":echo 'plugin stopping.'")))
+