Fix #294: support multiple values in code input in nREPL eval message (#298)

Author: borkdude

CHANGELOG.md

@@ -4,6 +4,10 @@ For a list of breaking changes, check [here](#breaking-changes).
 
 [Nbb](https://github.com/babashka/nbb): Scripting in Clojure on Node.js using [SCI](https://github.com/babashka/sci)
 
+## Unreleased
+
+- [#294](https://github.com/babashka/nbb/issues/294): support multiple values in code input in nREPL eval message
+
 ## 1.1.157
 
 - [#295](https://github.com/babashka/nbb/issues/295): add `swap-vals!` and `reset-vals!`

script/nbb_nrepl_tests.clj

@@ -4,10 +4,10 @@
    [babashka.wait :refer [wait-for-port]]
    [bencode.core :as bencode]
    [clojure.string :as str]
-   [clojure.test :as t :refer [deftest is testing]])
+   [clojure.test :as t :refer [deftest is testing]]
+   [test-utils])
   (:import [java.net Socket]))
 
-
 (def debug? false)
 
 (def port (atom 13337))
@@ -83,6 +83,7 @@
                                    "session" session "id" (new-id!)})
         (let [_msg (read-reply in session @id)
               _msg (read-reply in session @id)
+              _done-msg (read-reply in session @id)
               msg (read-reply in session @id)
               out (:out msg)
               _ (is (= "{:delayed-by \"1 second\"}" out))]))
@@ -375,6 +376,7 @@
                                    "(ns example)\n(defmacro foo [] 'lul)"
                                    "session" session "id" (new-id!)})
         (let [_ (read-reply in session @id)
+              _msg (read-reply in session @id)
               msg (read-reply in session @id)
               status (:status msg)
               _ (is (= ["done"] status))])
@@ -397,6 +399,34 @@
       (bencode/write-bencode os {"op" "eval" "code" "(js/process.exit 0)"
                                  "session" session "id" (new-id!)}))))
 
+(deftest eval-multiple-test
+  (nrepl-server)
+  (wait-for-port "localhost" @port)
+  (with-open [socket (Socket. "127.0.0.1" @port)
+              in (.getInputStream socket)
+              in (java.io.PushbackInputStream. in)
+              os (.getOutputStream socket)]
+    (bencode/write-bencode os {"op" "clone"})
+    (let [session (:new-session (read-msg (bencode/read-bencode in)))
+          id (atom 0)
+          new-id! #(swap! id inc)]
+      (testing "send multiple values to be evaluated"
+        (bencode/write-bencode os {"op" "eval"
+                                   "code"
+                                   "(+ 1 2 3) (ns dude) (defn foo [] 1) (foo)"
+                                   "session" session "id" (new-id!)})
+        (let [msg (read-reply in session @id)
+              _ (is (= "6" (:value msg)))
+              _msg (read-reply in session @id) ;; ns
+              msg (read-reply in session @id)
+              _ (is (= "#'dude/foo" (:value msg)))
+              msg (read-reply in session @id)
+              _ (is (= "1" (:value msg)))
+              msg (read-reply in session @id)
+              _ (is (= ["done"] (:status msg)))]))
+      (bencode/write-bencode os {"op" "eval" "code" "(js/process.exit 0)"
+                                 "session" session "id" (new-id!)}))))
+
 
 (defn -main [& _]
   (let [{:keys [:error :fail]} (t/run-tests 'nbb-nrepl-tests)]

script/test_utils.clj

@@ -6,6 +6,8 @@
                   str/lower-case
                   (str/starts-with? "win")))
 
+(defmethod clojure.test/report :begin-test-var [m]
+  (println "====" (:name (meta (:var m)))))
 
 (defmethod clojure.test/report :end-test-var [_m]
   (when-let [rc *report-counters*]

src/nbb/core.cljs

@@ -16,7 +16,8 @@
    [sci.impl.unrestrict :refer [*unrestricted*]]
    [sci.impl.vars :as vars]
    [sci.lang]
-   [shadow.esm :as esm])
+   [shadow.esm :as esm]
+   [cljs.tools.reader.reader-types])
   (:require-macros [nbb.macros :as macros]))
 
 (set! *unrestricted* true)
@@ -335,12 +336,12 @@
 
 (declare eval-next)
 
-(defn eval-seq [reader form opts]
+(defn eval-seq [reader form opts eval-next]
   (let [fst (first form)]
     (cond (= 'do fst)
           (reduce (fn [acc form]
                     (.then acc (fn [_]
-                                 (eval-seq reader form opts))))
+                                 (eval-seq reader form opts eval-next))))
                   (js/Promise.resolve nil)
                   (rest form))
           (= 'ns fst)
@@ -378,20 +379,24 @@
 
 (deftype Reject [v])
 
+
+(defn read-next [reader opts]
+  (try (sci/binding [sci/ns (:ns opts)]
+         (if-let [parse-fn (:parse-fn opts)]
+           (parse-fn reader)
+           (parse-next reader)))
+       (catch :default e
+         (js/Promise.reject e))))
+
 (defn eval-next
   "Evaluates top level forms asynchronously. Returns promise of last value."
   [prev-val reader opts]
-  (let [next-val (try (sci/binding [sci/ns (:ns opts)]
-                        (if-let [parse-fn (:parse-fn opts)]
-                          (parse-fn reader)
-                          (parse-next reader)))
-                      (catch :default e
-                        (js/Promise.reject e)))]
+  (let [next-val (read-next reader opts)]
     (if (instance? js/Promise next-val)
       next-val
       (if (not= :sci.core/eof next-val)
         (if (seq? next-val)
-          (eval-seq reader next-val opts)
+          (eval-seq reader next-val opts eval-next)
           (let [v (try
                     (sci/binding [sci/ns (:ns opts)
                                   sci/file (:file opts)]
@@ -403,9 +408,40 @@
               (recur v reader opts))))
         ;; wrap normal value in promise
         (js/Promise.resolve
-         (let [wrap (or (:wrap opts)
-                        identity)]
-           (wrap prev-val {:ns (:ns opts)})))))))
+         prev-val)))))
+
+(defn reader? [rdr]
+  (instance? cljs.tools.reader.reader-types/IndexingPushbackReader rdr))
+
+(def init-sentinel (js/Object.))
+
+(defn -eval-next*
+  "Evaluates top level forms asynchronously. Has options for REPL."
+  [prev-val next-val opts]
+  (if (instance? js/Promise next-val)
+    next-val
+    (if (identical? init-sentinel prev-val)
+      (if (seq? next-val)
+        (eval-seq next-val next-val opts -eval-next*)
+        (let [v (try
+                  (sci/binding [sci/ns (:ns opts)
+                                sci/file (:file opts)]
+                    (sci/eval-form (store/get-ctx) next-val))
+                  (catch :default e
+                    (->Reject e)))]
+          (if (instance? Reject v)
+            (js/Promise.reject (.-v v))
+            (recur v next-val opts))))
+      ;; wrap normal value in promise
+      (js/Promise.resolve
+       (let [wrap (or (:wrap opts)
+                      identity)]
+         (wrap prev-val {:ns (:ns opts)}))))))
+
+(defn eval-next*
+  "Evaluates top level forms asynchronously. Has options for REPL."
+  [val opts]
+  (-eval-next* init-sentinel val opts))
 
 (defn eval-string* [s opts]
   (let [reader (sci/reader s)]

src/nbb/impl/nrepl_server.cljs

@@ -88,42 +88,58 @@
         (pr-str value)))
     (pr-str value)))
 
+(defn send-value [request send-fn v]
+  (let [[v opts] v
+        sci-ns (:ns opts)]
+    (reset! last-ns sci-ns)
+    (sci/alter-var-root sci/*3 (constantly @sci/*2))
+    (sci/alter-var-root sci/*2 (constantly @sci/*1))
+    (sci/alter-var-root sci/*1 (constantly v))
+    (let [v (format-value (:nrepl.middleware.print/print request)
+                          (:nrepl.middleware.print/options request)
+                          v)]
+      (send-fn request {"value" v
+                        "ns" (str sci-ns)}))))
+
 (defn do-handle-eval [{:keys [ns code file
                               _load-file? _line] :as request} send-fn]
-  (with-async-bindings
-    {sci/ns ns
-     sci/file file
-     sci/print-length @sci/print-length
-     sci/print-newline true}
-    ;; we alter-var-root this because the print-fn may go out of scope in case
-    ;; of returned delays
-    (sci/alter-var-root sci/print-fn (constantly
-                                      (fn [s]
-                                        (send-fn request {"out" s}))))
-    (-> (nbb/eval-next nil (sci/reader code) {:ns ns
-                                              :file file
-                                              :wrap vector})
-        (.then (fn [v]
-                 (let [[v opts] v
-                       sci-ns (:ns opts)]
-                   (reset! last-ns sci-ns)
-                   (sci/alter-var-root sci/*3 (constantly @sci/*2))
-                   (sci/alter-var-root sci/*2 (constantly @sci/*1))
-                   (sci/alter-var-root sci/*1 (constantly v))
-                   (let [v (format-value (:nrepl.middleware.print/print request)
-                                         (:nrepl.middleware.print/options request)
-                                         v)]
-                     (send-fn request {"value" v
-                                       "ns" (str sci-ns)})))
-                 (send-fn request {"status" ["done"]})))
-        (.catch (fn [e]
-                  (sci/alter-var-root sci/*e (constantly e))
-                  (let [data (ex-data e)]
-                    (when-let [message (or (:message data) (.-message e))]
-                      (send-fn request {"err" (str message "\n")}))
-                    (send-fn request {"ex" (str e)
-                                      "ns" (str @sci/ns)
-                                      "status" ["done"]})))))))
+  (let [rdr (sci/reader code)
+        loop-fn (fn loop-fn [prev-val]
+                  (let [ns (or (:ns (second prev-val)) @last-ns ns)
+                        next-val (nbb/read-next rdr {:ns ns
+                                                     :file file
+                                                     :wrap vector})]
+                    (if (= :sci.core/eof next-val)
+                      (js/Promise.resolve prev-val)
+                      (let [v (nbb/eval-next* next-val {:ns ns
+                                                        :file file
+                                                        :wrap vector})]
+                        (.then v
+                               (fn [v]
+                                 ;; (prn :v v)
+                                 (send-value request send-fn v)
+                                 (loop-fn v)))))))]
+    (with-async-bindings
+      {sci/ns ns
+       sci/file file
+       sci/print-length @sci/print-length
+       sci/print-newline true}
+      ;; we alter-var-root this because the print-fn may go out of scope in case
+      ;; of returned delays
+      (sci/alter-var-root sci/print-fn (constantly
+                                        (fn [s]
+                                          (send-fn request {"out" s}))))
+      (-> (loop-fn nil)
+          (.catch (fn [e]
+                    (sci/alter-var-root sci/*e (constantly e))
+                    (let [data (ex-data e)]
+                      (when-let [message (or (:message data) (.-message e))]
+                        (send-fn request {"err" (str message "\n")}))
+                      (send-fn request {"ex" (str e)
+                                        "ns" (str @sci/ns)}))))
+          (.finally (fn []
+                      (send-fn request {"ns" (str last-ns)
+                                        "status" ["done"]})))))))
 
 (defn handle-eval [{:keys [ns] :as request} send-fn]
   (do-handle-eval (assoc request :ns (or (when ns

src/nbb/impl/repl.cljs

@@ -7,8 +7,7 @@
    [nbb.api :as api]
    [nbb.core :as nbb]
    [nbb.impl.repl-utils :refer [handle-complete*]]
-   [sci.core :as sci]
-   [sci.ctx-store :as store])
+   [sci.core :as sci])
   (:require-macros [nbb.macros :as macros]))
 
 (def last-ns (atom @sci/ns))
@@ -111,22 +110,12 @@
             (do (erase-processed rdr)
                 (if-not (= :sci.core/eof the-val)
                   (macros/with-async-bindings {sci/ns @last-ns}
-                    ;; (prn :pending @pending)
                     (-> (eval-expr
                          socket
-                         #(nbb/eval-next nil nil
-                                         {:ns @last-ns
-                                          :file @sci/file
-                                          :wrap vector
-                                          ;; TODO this is a huge workaround
-                                          ;; we should instead re-organize the code in nbb.core
-                                          :parse-fn (let [realized? (atom false)]
-                                                      (fn [_]
-                                                        (if-not @realized?
-                                                          (do
-                                                            (reset! realized? true)
-                                                            the-val)
-                                                          :sci.core/eof)))}))
+                         #(nbb/eval-next* the-val
+                                          {:ns @last-ns
+                                           :file @sci/file
+                                           :wrap vector}))
                         (.then (fn [v]
                                  (let [[val {:keys [ns]}] v]
                                    (reset! last-ns ns)