Streamline process response parsing

Author: arichiardi

inf-clojure.el

@@ -937,9 +937,14 @@ prefix argument PROMPT-FOR-SYMBOL, it prompts for a symbol name."
                (inf-clojure-symbol-at-point))))
     (comint-proc-query (inf-clojure-proc) (format (inf-clojure-var-source-form) var))))
 
+;;;; Response parsing
+;;;; ================
+
+(defvar inf-clojure--work-buffer-name "*Inf-Clojure Work Buffer*")
+
 ;; Originally from:
 ;;   https://github.com/glycerine/lush2/blob/master/lush2/etc/lush.el#L287
-(defun inf-clojure-results-from-process (process command &optional beg-string end-string)
+(defun inf-clojure--process-response (process command &optional beg-string end-string)
   "Send to PROCESS the given COMMAND.
 Return the result of COMMAND starting with BEG-STRING and ending
 with END-STRING if non-nil.  If BEG-STRING is nil, the result
@@ -973,17 +978,45 @@ the results buffer.  It cuts out the output from
         (when (and buffer-string (string-match inf-clojure-prompt buffer-string))
           (substring buffer-string 0 (match-beginning 0)))))))
 
+(defun inf-clojure--nil-string-match-p (string)
+  "Return true iff STRING is not nil.
+This function also takes into consideration weird escape
+character and matches if nil is anywhere within the input
+string."
+  (string-match-p "\\Ca*nil\\Ca*" string))
+
+(defun inf-clojure--read-response (response)
+  "Common post-processing of a process RESPONSE."
+  ;; The following reads the first LISP expression from the (string  )
+  (let ((read-data (when response (ignore-errors (read response)))))
+    (cond
+     ((null read-data) nil)
+     ((and (stringp read-data) (inf-clojure--nil-string-match-p read-data)) nil)
+     ((listp read-data) read-data))))
+
+(defun inf-clojure--process-response-match-p (match-p proc form)
+  "Eval MATCH-P on the response of sending to PROC the input FORM.
+Note that this function will add a \n to the end (or  )f the string
+for evaluation, therefore FORM should not include it."
+  (when-let ((response (inf-clojure--process-response proc form)))
+    (funcall match-p response)))
+
+(defun inf-clojure--non-nil-response-p (proc form)
+  "Return true iff PROC's response after evaluating FORM is not nil."
+  (inf-clojure--process-response-match-p
+                  (lambda (string)
+                    (not (inf-clojure--nil-string-match-p string)))
+                  proc form))
+
+;;;; Commands
+;;;; ========
+
 (defun inf-clojure-arglists (fn)
   "Send a query to the inferior Clojure for the arglists for function FN.
 See variable `inf-clojure-arglists-form'."
   (let* ((arglists-snippet (format (inf-clojure-arglists-form) fn))
-         (arglists-result (inf-clojure-results-from-process (inf-clojure-proc) arglists-snippet))
-         ;; The following reads the first LISP expression from the string
-         (arglists-data (when arglists-result (ignore-errors (read arglists-result)))))
-    (cond
-     ((null arglists-data) nil)
-     ((stringp arglists-data) arglists-data)
-     ((listp arglists-data) arglists-result))))
+         (arglist-response (inf-clojure--process-response (inf-clojure-proc) arglists-snippet))
+         (inf-clojure--read-response arglist-response))))
 
 (defun inf-clojure-show-arglists (prompt-for-symbol)
   "Show the arglists for function FN in the mini-buffer.
@@ -1051,24 +1084,9 @@ See variable `inf-clojure-buffer'."
 
 (defun inf-clojure-completions (expr)
   "Return a list of completions for the Clojure expression starting with EXPR."
-  (let* ((proc (inf-clojure-proc))
-         (comint-filt (process-filter proc))
-         (kept "")
-         completions)
-    (set-process-filter proc (lambda (_proc string) (setq kept (concat kept string))))
-    (unwind-protect
-        (let ((completion-snippet
-               (format
-                (inf-clojure-completion-form) (substring-no-properties expr))))
-          (process-send-string proc completion-snippet)
-          (while (and (not (string-match inf-clojure-prompt kept))
-                      (accept-process-output proc 2)))
-          (setq completions (read kept))
-          ;; Subprocess echoes output on Windows and OS X.
-          (when (and completions (string= (concat (car completions) "\n") completion-snippet))
-            (setq completions (cdr completions))))
-      (set-process-filter proc comint-filt))
-    completions))
+  (let* ((compl-snippet (format (inf-clojure-completion-form) (substring-no-properties expr)))
+         (compl-response (inf-clojure--process-response (inf-clojure-proc) compl-snippet)))
+    (inf-clojure--read-response compl-response)))
 
 (defconst inf-clojure-clojure-expr-break-chars " \t\n\"\'`><,;|&{(")
 
@@ -1226,13 +1244,6 @@ to suppress the usage of the target buffer discovery logic."
     (inf-clojure (inf-clojure-cmd (inf-clojure-project-type)))
     (rename-buffer target-buffer-name)))
 
-(defun inf-clojure--response-match-p (form match-p proc)
-  "Return MATCH-P on the result of sending FORM to PROC.
-Note that this function will add a \n to the end of the string
-for evaluation, therefore FORM should not include it."
-  (when-let* ((response (inf-clojure-results-from-process proc form)))
-    (funcall match-p response)))
-
 ;;;; Lumo
 ;;;; ====
 
@@ -1242,14 +1253,6 @@ for evaluation, therefore FORM should not include it."
   :type 'string
   :package-version '(inf-clojure . "2.0.0"))
 
-(defalias 'inf-clojure--lumo-p
-  (apply-partially 'inf-clojure--response-match-p
-                   inf-clojure--lumo-repl-form
-                   (lambda (string)
-                     (string-match-p "\\Ca*true\\Ca*" string)))
-  "Ascertain that PROC is a Lumo REPL.")
-
-
 ;;;; Planck
 ;;;; ====