Use the new PREPL in 1.10

To make the results returned from the REPL parsable this commit switches
to a dependency on Clojure 1.10, where the PREPL (Program REPL) was
introduced.

This commit also switches away from explicitly using a PrintStream in the
repl-log namespace; instead a clojure.java.io/writer is used. This feels
more Clojur-y.

`tap>` will be used in conjunction with a custom tap listener to
implement communication with the REPL which should be hidden from the
user. That is a future commit.

Author: mdiin

project.clj

@@ -3,7 +3,7 @@
   :url "http://example.com/FIXME"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"}
-  :dependencies [[org.clojure/clojure "1.9.0"]
+  :dependencies [[org.clojure/clojure "1.10.0-alpha4"]
                  [org.clojure/tools.logging "0.3.1"]
                  [org.clojure/tools.namespace "0.3.0-alpha4"]
                  [org.clojure/tools.nrepl "0.2.13"]
@@ -15,6 +15,7 @@
                  [neovim-client "0.1.2"]]
   :main ^:skip-aot socket-repl.system
   :target-path "target/%s"
-  :profiles {:uberjar {:aot [clojure.tools.logging.impl
+  :profiles {:dev {:jvm-opts ["-Dclojure.server.repl={:port 8888 :accept clojure.core.server/io-prepl}"]}
+             :uberjar {:aot [clojure.tools.logging.impl
                              socket-repl.socket-repl-plugin
                              socket-repl.system]}})

src/socket_repl/repl_log.clj

@@ -1,7 +1,11 @@
 (ns socket-repl.repl-log
   "Writes (presumably socket output) to the repl log."
   (:require
+    [clojure.edn :as edn]
     [clojure.core.async :as async]
+    [clojure.java.io :as io]
+    [clojure.string :as string]
+    [clojure.tools.logging :as log]
     [socket-repl.nrepl :as nrepl]
     [socket-repl.socket-repl :as socket-repl]
     [socket-repl.util :refer [log-start log-stop]])
@@ -34,27 +38,37 @@
     (nrepl/subscribe-output nrepl input-channel)
 
     ;; Write input to file.
-    (let [print-stream (PrintStream. file)]
+    (let [writer (io/writer file)]
       (async/thread
         (loop []
           (when-let [input (async/<!! input-channel)]
-            (.println print-stream (#'format-input input))
-            (.flush print-stream)
+            (binding [*out* writer]
+              (println input))
             (recur))))
-      (assoc repl-log :print-stream print-stream))))
+      (assoc repl-log :writer writer))))
 
 (defn stop
-  [{:keys [print-stream input-channel] :as repl-log}]
+  [{:keys [writer input-channel] :as repl-log}]
   (log-stop
     "repl-log"
-    (.close print-stream)
+    (.close writer)
     (async/close! input-channel)
-    (dissoc repl-log :print-stream :input-channel)))
+    (dissoc repl-log :writer :input-channel)))
+
+(defn format-stuff
+  [v]
+  (log/info v)
+  (case (:tag v)
+    (:out) (string/trim-newline (:val v))
+    (:ret) (str (:form v) " => " (:val v))
+    v))
 
 (defn new
   [socket-repl nrepl]
   {:socket-repl socket-repl
    :nrepl nrepl
    :file (File/createTempFile "socket-repl" ".txt")
    :print-stream nil
-   :input-channel (async/chan 1024)})
+   :input-channel (async/chan 1024 (comp
+                                     (filter #(not= (:tag %) :tap))
+                                     (map format-stuff)))})

src/socket_repl/socket_repl.clj

@@ -1,8 +1,10 @@
 (ns socket-repl.socket-repl
   "Provides a channel interface to socket repl input and output."
   (:require
+    [clojure.edn :as edn]
     [clojure.java.io :as io]
     [clojure.core.async :as async]
+    [clojure.tools.logging :as log]
     [socket-repl.util :refer [log-start log-stop]])
   (:import
     (java.net Socket)
@@ -74,10 +76,25 @@
     (async/close! input-channel)
     socket-repl))
 
+(defn deep-edn-read-string
+  [edn]
+  (if (string? edn)
+    (let [data (edn/read-string edn)]
+      (cond
+        (map? data) (into {}
+                          (map (juxt (comp deep-edn-read-string first)
+                                     (comp deep-edn-read-string second))
+                               data))
+        (vector? data) (into [] (map deep-edn-read-string data))
+        (list? data) (apply list (map deep-edn-read-string data))
+        (set? data) (into #{} (map deep-edn-read-string data))
+        :else data))
+    edn))
+
 (defn new
   []
   {:input-channel (async/chan 1024)
-   :output-channel (async/chan 1024)
+   :output-channel (async/chan 1024 (map edn/read-string))
    :connection (atom {:host nil
                       :port nil
                       :socket nil

src/socket_repl/socket_repl_plugin.clj

@@ -70,7 +70,6 @@
     "plugin"
     (let [mult (async/mult code-channel)]
       (async/tap mult (socket-repl/input-channel socket-repl))
-      (async/tap mult (repl-log/input-channel repl-log))
       (async/tap mult (nrepl/input-channel nrepl)))
 
     ;; Setup plugin functions.