Emacs pPREPL exploration

{:paths ["src"]
 :aliases
 {:repl-server
  {:extra-paths ["dev"] ; This makes dev/user.clj to load.
   :extra-deps {mvxcvi/puget {:mvn/version "1.3.4"}}
   :exec-fn jakub-stastny.dev.repl.server/start-server
   :exec-args {:name "repl-server"
               :port 5555
               :accept jakub-stastny.dev.repl.server/repl
               :server-daemon false}}}}

(ns jakub-stastny.dev.repl.server
  (:require [clojure.core.server :as rs]))

(defn repl []
  (clojure.main/repl :init rs/repl-init :read rs/repl-read
                     :prompt #(print (str "base-repl::" (ns-name *ns*) "=> "))))

(defn start-server [{:keys [port] :as opts}]
  (println (str "~ Starting socket REPL on port " port "."))
  (println (str "  Connect: rlwrap nc localhost " port))
  (println)
  (println      "Use *1 *2 *3 to get the last three values.")
  (println      "Use *e to get the last exception raised.")
  (println)
  (println      "Some clojure.repl fns: source apropos dir pst doc find-doc.")
  (println      "See https://clojuredocs.org/clojure.repl for a full reference.")
  (println)
  (println      "There's also javadoc from clojure.java.javadoc and pp & pprint from clojure.pprint.")
  (println)
  (println      "This is the base REPL. If you're in dev, you can upgrade it by running (start).")
  (println)

  (future (rs/start-server opts))
  (repl)

  ; Without this, :repl/quit or C-d won't exit the socket server.
  (System/exit 0))

(ns jakub-stastny.dev.repl
  (:require
   [clojure.string :as str]
   [clojure.core.server :as rs]
   [puget.printer :as puget]))

; This wouldn't be in the Emacs version, obviously.
(def colours {:red 31 :green 32 :yellow 33
            :blue 34 :purple 35 :cyan 36 :grey 37})

(defn colour "Wraps text in ANSI colour escape sequence" [colour text]
  (if-let [colour-code (colours colour)]
    (str "\033[" colour-code "m" text "\033[0m") text))

; @phronmophobic:
; Instead of embedding the values, I would use eval to create a function and call it:
; You can also do something like save the values in a dynamic variable and then grab the values inside of the eval from the dynamic variable, but I think wrapping in a function is more explicit and less brittle.
(defn contextual-eval [ctx expr]
  (let [f (eval `(fn [~@(keys ctx)] ~expr))]
    (apply f (vals ctx))))

(defmacro local-context []
  (let [symbols (keys &env)]
    (zipmap (map (fn [sym] `(quote ~sym)) symbols) symbols)))

; Do NOT extract :eval into a method or the local-context will get lost.
(defmacro break []
  `(do
     (clojure.main/repl
      :prompt #(print (colour :cyan "debug=> "))
      :read rs/repl-read
      :eval (partial contextual-eval (local-context))
      :print prn ;; puget.pprint
      )))

(defmacro try-break [expr]
  `(try ~expr (catch Exception ~'*e (break))))

; TODO: make this a command "ls" so we don't have to type "(ls)". This needs overriding read.
(defmacro ls [] `(keys (local-context)))

(def nesting-level (atom 0))

(defn error-prompt [e]
  #(print (str
           (colour :red (last (str/split (str (type e)) #"\."))) "."
           (colour :green *ns*) "."
           (colour :cyan @nesting-level)
           (colour :yellow" λ "))))

;; repl-read respects :repl/quit
(declare handle-error)
(defmacro start-nested-repl [*e]
  `(do
     (println "Inspect *e for details about the error.")
     (clojure.main/repl
      :prompt (error-prompt ~'*e)
      :caught handle-error
      :eval (partial contextual-eval (local-context))
      :read rs/repl-read
      :print prn ;; puget.pprint
      )))

(defn handle-error [*e]
  (swap! nesting-level inc)
  (println (ex-message *e) (or (ex-data *e) ""))
  (start-nested-repl *e)
  (swap! nesting-level dec))

(defn upgrade-init []
  ;; Here we might do some requires like Clojure does:
  ;; https://github.com/clojure/clojure/blob/master/src/clj/clojure/main.clj#L355
  ;; I've seen a better approach for :eval to wrap the whole code in (do (require...) (code)) so it's available anywhere, although that can easily lead to code that works only in the REPL.
  (rs/repl-init))

; This REPL is meant to be used as Pry in Ruby.
(defn upgrade-repl []
  (clojure.main/repl
   :caught #'handle-error
   :prompt #(print (str (colour :green (ns-name *ns*)) (colour :cyan" λ ")))
   :print prn ; TODO pretty-print
   :init #'upgrade-init
   :read rs/repl-read))

(ns user
  (:require [jakub-stastny.dev.repl :refer (upgrade-repl break try-break ls)]))

(defn start []
  ; http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded
  (def app {:start-time (new java.util.Date)}) ; Or (System/currentTimeMillis)

  (println "Fancy REPL started.")
  (println "Additional helpers: ls, break & try-break.")
  (println)
  (println "app:" (pr-str app))
  (println)
  (upgrade-repl))

(comment
  (start)

  ; Show local context.
  (let [a :b] (let [b :c] (ls)))

  (doseq [i [1 0]] (break) (/ 1 i)) ; Use :repl/quit or C-d to continue.
  (doseq [i [1 0]] (try-break (/ 1 i)))

  ;; ExceptionInfo with data.
  (throw (ex-info "Error" {:tired true}))
  *e

  (ls)
  {:message (ex-message *e) :data (ex-data *e)}

  ;; Other exceptions.
  (conj {} 1)
  {:message (ex-message *e) :data (ex-data *e)}
  ,)