Use macro to define vim api functions

Author: jebberjeb

TODO

@@ -0,0 +1,5 @@
+[_] Replace run-command!, run-command-async! everywhere
+	[X] samples
+	[_] socket-repl plugin
+[_] Test socket-repl plugin
+[_] Squash, merge branch

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

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

sample-plugin/src/sample_plugin/core.clj

@@ -12,17 +12,17 @@
       (fn [msg]
         ;; Plugin can call back to nvim if it wants to, while
         ;; its doing its own thing.
-        (nvim/run-command-async! ":echo 'incrementing'"
+        (nvim/vim-command-async ":echo 'incrementing'"
                                  (fn [_] nil))
         (swap! x inc)
         @x)))
 
   ;; Stay alive for a minute!
   (dotimes [n 60]
     (if (= 0 (mod n 10))
-      (nvim/run-command! (str ":echo 'plugin alive for " n " seconds.'")))
+      (nvim/vim-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.'"))
+  (nvim/vim-command ":let g:is_running=0")
+  (nvim/vim-command ":echo 'plugin stopping.'"))

src/neovim_client/nvim.clj

@@ -1,5 +1,6 @@
 (ns neovim-client.nvim
-  (:require [clojure.string :as str]
+  (:require [clojure.core.async :as async]
+            [clojure.string :as str]
             [neovim-client.message :as message :refer [->request-msg]]
             [neovim-client.rpc :as rpc]))
 
@@ -10,143 +11,89 @@
 
 ;; TODO - Check for connection, before allowing commands?
 
-(defn send-message!
-  [vim-command & args]
-  (rpc/send-message! (->request-msg vim-command (or args []))))
-
-(defn run-command!  [cmd-str] (send-message! "vim_command" cmd-str))
-
-(defn run-command-async!
-  [cmd-str f]
-  (rpc/send-message-async! (->request-msg "vim_command" [cmd-str]) f))
-
-(defn get-var-async
-  [var-name f]
-  (rpc/send-message-async! (->request-msg "vim_get_var" [var-name]) f))
-
-(defn get-vvar-async
-  [var-name f]
-  (rpc/send-message-async! (->request-msg "vim_get_vvar" [var-name]) f))
-
-(defn call-function-async
-  [f-name args f]
-  (rpc/send-message-async! (->request-msg "vim_call_function" [f-name args]) f))
-
-(defn get-api-info [] (send-message! "vim_get_api_info"))
+(defmacro defvim
+  [fn-name vim-command & args]
+  `(do
+     (defn ~(symbol (str fn-name "-async"))
+       [~@args f#]
+       (rpc/send-message-async!
+         (message/->request-msg ~vim-command [~@args])
+         f#))
+     (defn ~fn-name
+       [~@args]
+       (rpc/send-message!
+         (message/->request-msg ~vim-command [~@args])))))
+
+;; :let g:foo=1
+;; (vim-get-var-async "foo" println) => 1
+(defvim buffer-get-line "buffer_get_line" buffer line-num)
+(defvim buffer-line-count "buffer_line_count" buffer)
+(defvim buffer-get-name "buffer_get_name" buffer)
+(defvim buffer-set-line "buffer_set_line" buffer line-num line)
+(defvim vim-call-function "vim_call_function" f-name args)
+(defvim vim-command "vim_command" cmd-str)
+(defvim vim-get-api-info "vim_get_api_info")
+(defvim vim-get-current-buffer "vim_get_current_buffer")
+(defvim vim-get-current-line "vim_get_current_line")
+(defvim vim-get-current-window "vim_get_current_window")
+(defvim vim-get-buffers "vim_get_buffers")
+(defvim vim-get-var "vim_get_var" var-name)
+(defvim vim-get-vvar "vim_get_vvar" var-name)
+(defvim vim-get-windows "vim_get_windows")
+(defvim vim-set-current-line "vim_set_current_line" line)
+(defvim window-get-buffer "window_get_buffer" window)
+(defvim window-get-cursor "window_get_cursor" window)
+
+;; Special cases
+;; 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))
+(defn buffer-get-line-slice-async
+  [buffer start end f]
+  (buffer-get-line-slice*-async buffer start end true true f))
 
-(defn get-api-info-async [f]
-  (rpc/send-message-async! (->request-msg "vim_get_api_info" []) f))
+;; ***** Custom *****
 
-;; ***** Cursor *****
+;; TODO - fix custom names, move to another ns?
 
-(declare get-current-window-async)
 (defn get-cursor-location-async
   "Gets the cursor's current position as a tuple (row, col) asynchronously."
   [f]
-  (get-current-window-async
-    (fn [window]
-      (rpc/send-message-async!
-        (->request-msg "window_get_cursor" [window]) f))))
-
-;; ***** Lines *****
-
-(defn get-current-line [] (send-message! "vim_get_current_line"))
-
-(defn set-current-line!  [line] (send-message! "vim_set_current_line" line))
-
-;; ***** Windows *****
-
-(defn get-current-window-async
-  "Gets a reference to the current window asynchronously."
-  [f]
-  (rpc/send-message-async! (->request-msg "vim_get_current_window" []) f))
-
-;; ***** Buffers *****
-
-(defn get-current-buffer
-  "Returns a reference to 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]
-  (send-message! "buffer_set_line" buffer line-num line))
-
-(defn buffer-set-line-async!
-  ([buffer line-num line]
-   (buffer-set-line-async! buffer line-num line identity))
-  ([buffer line-num line f]
-   (rpc/send-message-async! (->request-msg "buffer_set_line"
-                                           [buffer line-num line]) f)))
-
-(defn buffer-get-line
-  [buffer line-num]
-  (send-message! "buffer_get_line" buffer line-num))
-
-(defn buffer-get-line-async
-  [buffer line-num f]
-  (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 *****
+  (vim-get-current-window-async #(window-get-cursor-async % f)))
 
 (defn buffer-update-lines!
   "Alter each line of the buffer using the function."
   [buffer update-fn]
-  (doseq [n (range (get-buffer-line-count buffer))]
-    (buffer-get-line-async buffer n #(buffer-set-line-async! buffer n
-                                                             (update-fn %)))))
-
- ;; TODO: Do this with `get-buffer-line-slice`
-(defn buffer-get-text
-  "Get the buffer's text as a single string."
-  [buffer]
-  (let [buf-size (get-buffer-line-count buffer)
-        lines (map (partial buffer-get-line buffer) (range buf-size))]
-    (str/join "\n" lines)))
-
+  (doseq [n (range (buffer-line-count buffer))]
+    (buffer-get-line-async buffer n #(buffer-set-line-async buffer n
+                                                            (update-fn %)
+                                                            identity))))
 (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
+  (vim-get-current-buffer-async
+    (fn [buffer] (buffer-get-line-slice-async
                    buffer 0 -1 (fn [lines] (f (str/join "\n" lines)))))))
 
-;; TODO - make it wipe out text in the buffer after the last line of new text.
 (defn buffer-set-text!
+  "Replace the contents of the buffer with `text`."
   [buffer text]
   (let [lines (str/split text #"\n")]
     (doseq [n (range (count lines))]
-      (buffer-set-line! buffer n (nth lines n)))))
-
-(defn hsplit! [] (run-command! "new"))
-(defn vsplit! [] (run-command! "vnew"))
+      (buffer-set-line buffer n (nth lines n)))))
 
 (defn get-current-word-async
   "Get the current word asynchronously."
   [f]
-  (call-function-async "expand" ["<cword>"] f))
-
-;; TODO
-;; the rest of the functions in (get_api_info)
+  (vim-call-function-async "expand" ["<cword>"] f))
+
+(defn buffer-visible?-async
+  "Returns a channel which will contain true if the buffer is currently
+  visible."
+  [buffer-name]
+  (async/go
+    (let [visible-buffers (map (comp buffer-get-name window-get-buffer)
+                               (vim-get-windows))]
+      ((set visible-buffers) buffer-name))))