Use tools.reader for parsing

Author: jebberjeb

deploy-local.sh

@@ -1,5 +1,5 @@
 lein uberjar
-cp target/uberjar/socket-repl-plugin-0.1.0-SNAPSHOT-standalone.jar .
+cp target/uberjar/socket-repl-plugin-0.1.0-standalone.jar .
 rm -rf ~/.vim/bundle/clojure-socketrepl.nvim
 cd ..
 cp -rf clojure-socketrepl.nvim  ~/.vim/bundle

plugin/socketrepl.vim

@@ -8,7 +8,7 @@ let s:not_ready = "SocketREPL plugin not ready (starting)"
 function! StartIfNotRunning()
     if g:is_running == 0
         echo 'Starting SocketREPL plugin...'
-        let jar_file_path = s:p_dir . '/../' . 'socket-repl-plugin-0.1.0-SNAPSHOT-standalone.jar'
+        let jar_file_path = s:p_dir . '/../' . 'socket-repl-plugin-0.1.0-standalone.jar'
         call jobstart(['java', '-jar', jar_file_path], {'rpc': v:true})
         let g:is_running = 1
     endif

project.clj

@@ -1,4 +1,4 @@
-(defproject socket-repl-plugin "0.1.0-SNAPSHOT"
+(defproject socket-repl-plugin "0.1.0"
   :description "FIXME: write description"
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
@@ -7,6 +7,7 @@
                  [org.clojure/tools.logging "0.3.1"]
                  [org.clojure/tools.namespace "0.2.11"]
                  [org.clojure/tools.nrepl "0.2.12"]
+                 [org.clojure/tools.reader "1.0.0-beta4"]
                  [log4j/log4j "1.2.17" :exclusions [javax.mail/mail
                                                     javax.jms/jms
                                                     com.sun.jmdk/jmxtools

src/socket_repl/parser.clj

@@ -0,0 +1,49 @@
+(ns socket-repl.parser
+  (:require
+    [clojure.string :as string]
+    [clojure.tools.reader.reader-types :as reader-types]
+    [clojure.tools.reader :as reader]))
+
+(defn position
+  "Returns the zero-indexed position in a code string given line and column."
+  [code-str row col]
+  (->> code-str
+       string/split-lines
+       (take (dec row))
+       (string/join)
+       count
+       (+ col (dec row)) ;; `(dec row)` to include for newlines
+       dec
+       (max 0)))
+
+(defn search-start
+  "Find the place to start reading from. Search backwards from the starting
+  point, looking for a '[', '{', or '('. If none can be found, search from
+  the beginning of `code-str`."
+  [code-str start-row start-col]
+  (let [openers #{\[ \( \{}
+        start-position (position code-str start-row start-col)]
+    (if (contains? openers (nth code-str start-position))
+      start-position
+      (let [code-str-prefix (subs code-str 0 start-position)]
+        (->> openers
+             (map #(string/last-index-of code-str-prefix %))
+             (remove nil?)
+             (apply max 0))))))
+
+(defn read-next
+  "Reads the next expression from some code. Uses an `indexing-pushback-reader`
+  to determine how much was read, and return that substring of the original
+  `code-str`, rather than what was actually read by the reader."
+  [code-str start-row start-col]
+  (let [code-str (subs code-str (search-start code-str start-row start-col))
+        rdr (reader-types/indexing-push-back-reader code-str)]
+    ;; Read a form, but discard it, as we want the original string.
+    (reader/read rdr)
+    (subs code-str
+          0
+          ;; Even though this returns the position *after* the read, this works
+          ;; because subs is end point exclusive.
+          (position code-str
+                    (reader-types/get-line-number rdr)
+                    (reader-types/get-column-number rdr)))))

src/socket_repl/repl_log.clj

@@ -18,6 +18,10 @@
   [repl-log]
   (:input-channel repl-log))
 
+(defn format-input
+  [s]
+  s)
+
 (defn start
   [{:keys [file input-channel socket-repl nrepl] :as repl-log}]
 
@@ -34,7 +38,7 @@
       (async/thread
         (loop []
           (when-let [input (async/<!! input-channel)]
-            (.println print-stream input)
+            (.println print-stream (#'format-input input))
             (.flush print-stream)
             (recur))))
       (assoc repl-log :print-stream print-stream))))

src/socket_repl/socket_repl_plugin.clj

@@ -13,31 +13,11 @@
     [neovim-client.message :as message]
     [neovim-client.nvim :as nvim]
     [socket-repl.nrepl :as nrepl]
+    [socket-repl.parser :as parser]
     [socket-repl.repl-log :as repl-log]
     [socket-repl.socket-repl :as socket-repl]
     [socket-repl.util :refer [log-start log-stop]]))
 
-(defn position
-  "Find the position in a code string given line and column."
-  [code-str [y x]]
-  (->> code-str
-       string/split-lines
-       (take (dec y))
-       (string/join "\n")
-       count
-       (+ (inc x))))
-
-(defn get-form-at
-  "Returns the enclosing form from a string a code using [row col]
-  coordinates."
-  [code-str coords]
-  (let [pos (position code-str coords)]
-    (read-string
-      ;; Start at the last index of paren on or before `pos`, read a form.
-      (subs code-str (if (= \( (.charAt code-str pos))
-                       pos
-                       (.lastIndexOf (subs code-str 0 pos) "("))))))
-
 (defn write-error
   "Write a throwable's stack trace to the repl log."
   [repl-log throwable]
@@ -135,10 +115,10 @@
       (run-command
         plugin
         (fn [msg]
-          (let [coords (api-ext/get-cursor-location nvim)
+          (let [[row col] (api-ext/get-cursor-location nvim)
                 buffer-text (api-ext/get-current-buffer-text nvim)]
             (try
-              (async/>!! code-channel (get-form-at buffer-text coords))
+              (async/>!! code-channel (parser/read-next buffer-text row (inc col)))
               (catch Throwable t
                 (log/error t "Error evaluating a form")
                 (write-error repl-log t)))))))

test/socket_repl/parser_test.clj

@@ -0,0 +1,27 @@
+(ns socket-repl.parser-test
+  (:require
+    [clojure.test :as test :refer [deftest is]]
+    [socket-repl.parser :as parser]))
+
+(deftest parse
+  (is (= "(println ::Foo)"
+         (parser/read-next "(println ::Foo)\n(println 'bar)\n::baz"
+                           1 2)))
+  (is (= "println"
+         (parser/read-next "println ::Foo)\n(println 'bar)\n::baz"
+                           1 2)))
+  (is (= "(println 'bar)"
+         (parser/read-next "println ::Foo)\n(println 'bar)\n::baz"
+                           2 3)))
+  (is (= "{:foo :bar}"
+         (parser/read-next (str "println ::Foo)\n(println 'bar)\n::baz blah"
+                                " blah blah\n(doit {:foo :bar} x)")
+                           4 10)))
+  (is (= "(foo bar)"
+         (parser/read-next "(foo bar)"
+                                1 1)))
+  (is (= "(foo bar)"
+         (parser/read-next "\n\n\n\n(foo bar)"
+                           5 1))))
+
+;(clojure.test/run-tests 'socket-repl.parser-test)