Remove global state

Author: jebberjeb

TODO

@@ -1,5 +1,5 @@
-[_] Replace run-command!, run-command-async! everywhere
-	[X] samples
-	[_] socket-repl plugin
-[_] Test socket-repl plugin
-[_] Squash, merge branch
+global-state
+	[X] finish refactoring nvim, rpc
+	[X] from debug session, stop, then start (restart) should work
+	[X] make sure sample plugins still work
+	[_] clojure socket repl plugin refactor

sample-plugin-simple/src/sample_plugin/core.clj

@@ -4,7 +4,7 @@
 
 (defn -main
   [& args]
-  (nvim/connect!)
-  (nvim/vim-command ":new")
-  (let [cur-buf (nvim/vim-get-current-buffer)]
-    (nvim/buffer-set-text! cur-buf "Sample plugin was here!")))
+  (let [nvim (nvim/new)
+        cur-buf (nvim/vim-get-current-buffer nvim)]
+    (nvim/vim-command nvim ":new")
+    (nvim/buffer-set-text! nvim cur-buf "Sample plugin was here!")))

sample-plugin/src/sample_plugin/core.clj

@@ -4,25 +4,26 @@
 
 (defn -main
   [& args]
-  (nvim/connect!)
-
-  (let [x (atom 0)]
+  (let [nvim (nvim/new)
+        x (atom 0)]
     (nvim/register-method!
+      nvim
       "count"
       (fn [msg]
         ;; Plugin can call back to nvim if it wants to, while
         ;; its doing its own thing.
-        (nvim/vim-command-async ":echo 'incrementing'"
-                                 (fn [_] nil))
+        (nvim/vim-command-async nvim
+                                ":echo 'incrementing'"
+                                (fn [_] nil))
         (swap! x inc)
-        @x)))
+        @x))
 
-  ;; Stay alive for a minute!
-  (dotimes [n 60]
-    (if (= 0 (mod n 10))
-      (nvim/vim-command (str ":echo 'plugin alive for " n " seconds.'")))
-    (Thread/sleep 1000))
+    ;; Stay alive for a minute!
+    (dotimes [n 60]
+      (if (= 0 (mod n 10))
+        (nvim/vim-command nvim (str ":echo 'plugin alive for " n " seconds.'")))
+      (Thread/sleep 1000))
 
-  ;; Let nvim know we're shutting down.
-  (nvim/vim-command ":let g:is_running=0")
-  (nvim/vim-command ":echo 'plugin stopping.'"))
+    ;; Let nvim know we're shutting down.
+    (nvim/vim-command nvim ":let g:is_running=0")
+    (nvim/vim-command nvim ":echo 'plugin stopping.'")))

src/neovim_client/nvim.clj

@@ -6,22 +6,23 @@
 
 ;; ***** Public *****
 
-(def connect! rpc/connect!)
+(def new rpc/new)
 (def register-method! rpc/register-method!)
-
-;; TODO - Check for connection, before allowing commands?
+(def stop rpc/stop)
 
 (defmacro defvim
   [fn-name vim-command & args]
   `(do
      (defn ~(symbol (str fn-name "-async"))
-       [~@args f#]
+       [nvim# ~@args f#]
        (rpc/send-message-async!
+         nvim#
          (message/->request-msg ~vim-command [~@args])
          f#))
      (defn ~fn-name
-       [~@args]
+       [nvim# ~@args]
        (rpc/send-message!
+         nvim#
          (message/->request-msg ~vim-command [~@args])))))
 
 ;; :let g:foo=1
@@ -52,62 +53,66 @@
 ;; TODO give x, y correct names
 (defvim buffer-get-line-slice* "buffer_get_line_slice" buffer start end x y)
 (defn buffer-get-line-slice
-  [buffer start end]
-  (buffer-get-line-slice* buffer start end true true))
+  [nvim buffer start end]
+  (buffer-get-line-slice* nvim buffer start end true true))
 (defn buffer-get-line-slice-async
-  [buffer start end f]
-  (buffer-get-line-slice*-async buffer start end true true f))
+  [nvim buffer start end f]
+  (buffer-get-line-slice*-async nvim buffer start end true true f))
 
 ;; ***** Custom *****
 
 ;; TODO - fix custom names, move to another ns?
 
 (defn get-cursor-location
   "Gets the cursor's current position as a tuple (row, col)."
-  []
-  (window-get-cursor (vim-get-current-window)))
+  [nvim]
+  (window-get-cursor nvim (vim-get-current-window nvim)))
 
 (defn get-cursor-location-async
   "Gets the cursor's current position as a tuple (row, col) asynchronously."
-  [f]
-  (vim-get-current-window-async #(window-get-cursor-async % f)))
+  [nvim f]
+  (vim-get-current-window-async nvim #(window-get-cursor-async nvim % f)))
 
 (defn buffer-update-lines!
   "Alter each line of the buffer using the function."
-  [buffer update-fn]
-  (doseq [n (range (buffer-line-count buffer))]
-    (buffer-get-line-async buffer n #(buffer-set-line-async buffer n
-                                                            (update-fn %)
-                                                            identity))))
+  [nvim buffer update-fn]
+  (doseq [n (range (buffer-line-count nvim buffer))]
+    (buffer-get-line-async nvim buffer n #(buffer-set-line-async nvim
+                                                                 buffer n
+                                                                 (update-fn %)
+                                                                 identity))))
 (defn get-current-buffer-text
   "Convenience function to get the current buffer's text."
-  []
-  (str/join "\n" (buffer-get-line-slice (vim-get-current-buffer) 0 -1)))
+  [nvim]
+  (str/join "\n" (buffer-get-line-slice nvim (vim-get-current-buffer nvim)
+                                        0 -1)))
 
 (defn get-current-buffer-text-async
   "Convenience function to get the current buffer's text asynchronously."
-  [f]
+  [nvim f]
   (vim-get-current-buffer-async
+    nvim
     (fn [buffer] (buffer-get-line-slice-async
-                   buffer 0 -1 (fn [lines] (f (str/join "\n" lines)))))))
+                   nvim buffer 0 -1 (fn [lines] (f (str/join "\n" lines)))))))
 
 (defn buffer-set-text!
   "Replace the contents of the buffer with `text`."
-  [buffer text]
+  [nvim buffer text]
   (let [lines (str/split text #"\n")]
     (doseq [n (range (count lines))]
-      (buffer-set-line buffer n (nth lines n)))))
+      (buffer-set-line nvim buffer n (nth lines n)))))
 
 (defn get-current-word-async
   "Get the current word asynchronously."
-  [f]
-  (vim-call-function-async "expand" ["<cword>"] f))
+  [nvim f]
+  (vim-call-function-async nvim "expand" ["<cword>"] f))
 
 (defn buffer-visible?-async
   "Returns a channel which will contain true if the buffer is currently
   visible."
-  [buffer-name]
+  [nvim buffer-name]
   (async/go
-    (let [visible-buffers (map (comp buffer-get-name window-get-buffer)
-                               (vim-get-windows))]
+    (let [visible-buffers (map (comp #(buffer-get-name nvim %)
+                                     #(window-get-buffer nvim %))
+                               (vim-get-windows nvim))]
       ((set visible-buffers) buffer-name))))

src/neovim_client/rpc.clj

@@ -8,92 +8,105 @@
   (:import [java.io DataInputStream DataOutputStream]
            [java.net Socket]))
 
-(def out-chan (atom nil))
-(def in-chan (atom nil))
-(def msg-table (atom {}))
-(def method-table (atom {}))
-
-(defn method-not-found
+(defn- method-not-found
   [msg]
   (log/error "method not found for msg " msg)
   (str "method not found - " (method msg)))
 
-(defn create-input-channel
+(defn- create-input-channel
   "Read messages from the input stream, put them on a channel."
   [input-stream]
   (let [chan (async/chan 1024)
         input-stream (DataInputStream. input-stream)]
-    (async/go-loop []
-      (let [msg (msgpack/unpack-stream input-stream)]
+    (async/go-loop
+      []
+      (when-let [msg (msgpack/unpack-stream input-stream)]
         (log/info "stream -> msg -> in chan: " msg)
-        (async/>! chan msg))
-      (recur))
-    chan))
+        (async/>! chan msg)
+        (recur)))
+    [chan input-stream]))
 
-(defn write-msg!
+(defn- write-msg!
   [packed-msg out-stream]
   (doseq [b packed-msg]
     (.writeByte out-stream b))
   (.flush out-stream))
 
-(defn create-output-channel
+(defn- create-output-channel
   "Make a channel to read messages from, write to output stream."
   [output-stream]
   (let [chan (async/chan 1024)
         output-stream (DataOutputStream. output-stream)]
-    (async/go-loop []
-      (let [msg (async/<! chan)]
+    (async/go-loop
+      []
+      (when-let [msg (async/<! chan)]
         (log/info "stream <- msg <- out chan: " msg)
-        (write-msg! (msgpack/pack msg) output-stream))
-      (recur))
+        (write-msg! (msgpack/pack msg) output-stream)
+        (recur)))
     chan))
 
-(declare send-message-async!)
-
-(defn connect*
-  [input-stream output-stream]
-  (reset! in-chan (create-input-channel input-stream))
-  (reset! out-chan (create-output-channel output-stream))
-
-  ;; Handle stuff on the input channel -- where should this live?
-  (async/go-loop []
-    ;; TODO - let the in-chan, if we leave this code here.
-    (let [msg (async/<! @in-chan)]
-      (condp = (msg-type msg)
-
-        msg/+response+
-        (let [f (:fn (get @msg-table (id msg)))]
-          (swap! msg-table dissoc (id msg))
-          (f (value msg)))
-
-        msg/+request+
-        (let [f (get @method-table (method msg) method-not-found)
-              result (f msg)]
-          (send-message-async! (->response-msg (id msg) result) nil))))
-    (recur)))
-
 ;; ***** Public *****
 
-(defn connect!
-  "Connect to msgpack-rpc channel via standard io or TCP socket."
-  ([] (connect* System/in System/out))
-  ([host port]
-   (let [socket (java.net.Socket. host port)]
-     (.setTcpNoDelay socket true)
-     (connect* (.getInputStream socket) (.getOutputStream socket)))))
-
 (defn send-message-async!
-  [msg callback-fn]
+  [{:keys [message-table out-chan]} msg callback-fn]
   (if (= msg/+request+ (msg-type msg))
-    (swap! msg-table assoc (id msg) {:msg msg :fn callback-fn}))
-  (async/put! @out-chan msg))
+    (swap! message-table assoc (id msg) {:msg msg :fn callback-fn}))
+  (async/put! out-chan msg))
 
 (defn send-message!
-  [msg]
+  [component msg]
   (let [p (promise)]
-    (send-message-async! msg (partial deliver p))
+    (send-message-async! component msg (partial deliver p))
     @p))
 
 (defn register-method!
-  [method f]
+  [{:keys [method-table]} method f]
   (swap! method-table assoc method f))
+
+(defn stop
+  "Stop the connection. Right now, this probably only works for debug, when
+  connected to socket. Don't think we should be trying to .close STDIO streams."
+  [{:keys [input-stream output-stream out-chan in-chan data-stream]}]
+  (async/close! out-chan)
+  (async/close! in-chan)
+  (.close data-stream)
+  (.close input-stream)
+  (.close output-stream))
+
+(defn new*
+  [input-stream output-stream]
+  (let [[in-chan data-stream] (create-input-channel input-stream)
+        message-table (atom {})
+        method-table (atom {})
+        component {:input-stream input-stream
+                   :data-stream data-stream
+                   :output-stream output-stream
+                   :out-chan (create-output-channel output-stream) 
+                   :in-chan in-chan
+                   :message-table message-table
+                   :method-table method-table}]
+    (async/go-loop
+      []
+      (when-let [msg (async/<! in-chan)]
+        (condp = (msg-type msg)
+
+          msg/+response+
+          (let [f (:fn (get @message-table (id msg)))]
+            (swap! message-table dissoc (id msg))
+            (f (value msg)))
+
+          msg/+request+
+          (let [f (get @method-table (method msg) method-not-found)
+                result (f msg)]
+            (send-message-async!
+              component (->response-msg (id msg) result) nil)))
+        (recur)))
+    component))
+
+(defn new
+  "Connect to msgpack-rpc channel via standard io or TCP socket."
+  ([] (new* System/in System/out))
+  ([host port]
+   (let [socket (java.net.Socket. host port)]
+     (.setTcpNoDelay socket true)
+     (new* (.getInputStream socket) (.getOutputStream socket)))))

src/user.clj

@@ -3,7 +3,7 @@
     [neovim-client.nvim :as nvim]
     [clojure.tools.namespace.repl :refer [refresh]]))
 
-(defn go
-  "Start the plugin."
+(defn connection
+  "Get an nvim connection."
   []
-  (nvim/connect! "localhost" 7777))
+  (nvim/new "localhost" 7777))

tmux-run-dev.sh

@@ -10,4 +10,4 @@ tmux send-keys "NVIM_LISTEN_ADDRESS=127.0.0.1:7777 nvim" C-m
 tmux split
 tmux send-keys 'rlwrap java -cp "$(cat .classpath)" clojure.main' C-m
 tmux send-keys '(println "Plugin repl connecting to nvim")' C-m
-tmux send-keys '(go)' C-m
+tmux send-keys '(def c (connection))' C-m