[elpa] externals/org 6efb073463: ob-clojure.el: Fix results output, support clojure-cli

[ELPA Syncer]

branch: externals/org
commit 6efb073463481ee572eb3bb1155cc3b0d6987df6
Author: Daniel Kraus <daniel@kraus.my>
Commit: Daniel Kraus <daniel@kraus.my>

    ob-clojure.el: Fix results output, support clojure-cli
    
    * lisp/ob-clojure.el (org-babel-clojure-backend): Add support for
    clojure-cli.
    * lisp/ob-clojure.el (org-babel-clojurescript-backend): Move nbb to
    clojurescript.
    * lisp/ob-clojure.el (org-babel-expand-body:clojure)
    * lisp/ob-clojure.el (ob-clojure-eval-with-cider): Return only the
    last expression when :results is not set or value, and return only
    stdout when :results is set to output.
    * lisp/ob-clojure.el (ob-clojure-eval-with-cmd): Rename function as
    it is not only for babashka.
    * lisp/ob-clojure.el (org-babel-execute:clojure): Differentiate
    between Clojure and ClojureScript source blocks.
    
    The problem was that the ob-clojure results where not correctly
    taking the results parameter into account.
    E.g. with the cider backend, you would get all printed or returned
    values for each line in your block:
    
    (def small-map {:a 2 :b 4 :c 8})
    {:some :map}
    (prn :xx)
    (:b small-map)
    
    | #'user/small-map |
    | {:some :map}     |
    | 4                |
    
    or for babashka you would only get the printed values but not the
    last return value:
    (def small-map {:a 2 :b 4 :c 8})
    {:some :map}
    (prn :xx)
    (:b small-map)
    
    : :xx
    
    Now when you specify :results value, the result is only the last
    returned value, and with :results output you get all values
    printed to stdout.
    So the examples above would all result in the same:
    (def small-map {:a 2 :b 4 :c 8})
    {:some :map}
    (prn :xx)
    (:b small-map)
    
    : 4
---
 etc/ORG-NEWS       |  23 ++++++++
 lisp/ob-clojure.el | 156 +++++++++++++++++++++++++++++++++--------------------
 lisp/org-compat.el |   4 ++
 3 files changed, 126 insertions(+), 57 deletions(-)

diff --git a/etc/ORG-NEWS b/etc/ORG-NEWS
index b9d7b3459d..4ca13af17b 100644
--- a/etc/ORG-NEWS
+++ b/etc/ORG-NEWS
@@ -96,6 +96,21 @@ The face ~org-agenda-calendar-daterange~ is used to show 
entries with
 a date range in the agenda.  It inherits from the default face in
 order to remain backward-compatible.
 
+*** New ~org-babel-clojurescript-backend~ option to choose ClojureScript 
backend
+
+Before, a ClojureScript source block used the same backend as Clojure,
+configured in ~org-babel-clojure-backend~ and relied on an undocumented
+~:target~ paramter.
+
+Now, there's ~org-babel-clojurescript-backend~ to determine the
+backend used for evaluation of ClojureScript.
+
+*** Support for Clojure CLI in ~ob-clojure~
+
+~ob-clojure~ now supports executing babel source blocks with the
+official [[https://clojure.org/guides/deps_and_cli][Clojure CLI tools]].
+The command can be customized with ~ob-clojure-cli-command~.
+
 ** New features
 *** ~org-metaup~ and ~org-metadown~ now act on headings in region
 
@@ -116,6 +131,14 @@ selection.
 TODO state, priority, tags, statistics cookies, and COMMENT keywords
 are allowed in the tree structure.
 
+** Miscellaneous
+*** Remove undocumented ~:target~ header parameter in ~ob-clojure~
+
+The ~:target~ header was only used internally to distinguish
+from Clojure and ClojureScript.
+This is now handled with an optional function parameter in
+the respective functions that need this information.
+
 * Version 9.6
 
 ** Important announcements and breaking changes
diff --git a/lisp/ob-clojure.el b/lisp/ob-clojure.el
index 5f589db00d..70e0321543 100644
--- a/lisp/ob-clojure.el
+++ b/lisp/ob-clojure.el
@@ -25,20 +25,21 @@
 
 ;;; Commentary:
 
-;; Support for evaluating Clojure code
+;; Support for evaluating Clojure / ClojureScript code.
 
 ;; Requirements:
 
 ;; - Clojure (at least 1.2.0)
 ;; - clojure-mode
-;; - inf-clojure, Cider, SLIME, babashka or nbb
+;; - babashka, nbb, Clojure CLI tools, Cider, inf-clojure or SLIME
 
 ;; For clojure-mode, see https://github.com/clojure-emacs/clojure-mode
-;; For inf-clojure, see https://github.com/clojure-emacs/inf-clojure
-;; For Cider, see https://github.com/clojure-emacs/cider
-;; For SLIME, see https://slime.common-lisp.dev
 ;; For babashka, see https://github.com/babashka/babashka
 ;; For nbb, see https://github.com/babashka/nbb
+;; For Clojure CLI tools, see https://clojure.org/guides/deps_and_cli
+;; For Cider, see https://github.com/clojure-emacs/cider
+;; For inf-clojure, see https://github.com/clojure-emacs/inf-clojure
+;; For SLIME, see https://slime.common-lisp.dev
 
 ;; For SLIME, the best way to install its components is by following
 ;; the directions as set out by Phil Hagelberg (Technomancy) on the
@@ -78,20 +79,33 @@
 
 (defcustom org-babel-clojure-backend (cond
                                       ((executable-find "bb") 'babashka)
-                                      ((executable-find "nbb") 'nbb)
+                                      ((executable-find "clojure") 
'clojure-cli)
                                       ((featurep 'cider) 'cider)
                                       ((featurep 'inf-clojure) 'inf-clojure)
                                       ((featurep 'slime) 'slime)
                                      (t nil))
   "Backend used to evaluate Clojure code blocks."
   :group 'org-babel
-  :package-version '(Org . "9.6")
+  :package-version '(Org . "9.7")
   :type '(choice
-         (const :tag "inf-clojure" inf-clojure)
+         (const :tag "babashka" babashka)
+          (const :tag "clojure-cli" clojure-cli)
          (const :tag "cider" cider)
+         (const :tag "inf-clojure" inf-clojure)
          (const :tag "slime" slime)
-         (const :tag "babashka" babashka)
+         (const :tag "Not configured yet" nil)))
+
+(defcustom org-babel-clojurescript-backend
+  (cond
+   ((or (executable-find "nbb") (executable-find "npx")) 'nbb)
+   ((featurep 'cider) 'cider)
+   (t nil))
+  "Backend used to evaluate ClojureScript code blocks."
+  :group 'org-babel
+  :package-version '(Org . "9.7")
+  :type '(choice
          (const :tag "nbb" nbb)
+         (const :tag "cider" cider)
          (const :tag "Not configured yet" nil)))
 
 (defcustom org-babel-clojure-default-ns "user"
@@ -100,19 +114,29 @@
   :group 'org-babel)
 
 (defcustom ob-clojure-babashka-command (executable-find "bb")
-  "Path to the babashka executable."
+  "Babashka command used by the Clojure `babashka' backend."
   :type '(choice file (const nil))
   :group 'org-babel
   :package-version '(Org . "9.6"))
 
-(defcustom ob-clojure-nbb-command (executable-find "nbb")
-  "Path to the nbb executable."
-  :type '(choice file (const nil))
+(defcustom ob-clojure-nbb-command (or (executable-find "nbb")
+                                      (when-let (npx (executable-find "npx"))
+                                        (concat npx " nbb")))
+  "Nbb command used by the ClojureScript `nbb' backend."
+  :type '(choice string (const nil))
   :group 'org-babel
-  :package-version '(Org . "9.6"))
+  :package-version '(Org . "9.7"))
 
-(defun org-babel-expand-body:clojure (body params)
-  "Expand BODY according to PARAMS, return the expanded body."
+(defcustom ob-clojure-cli-command (when-let (cmd (executable-find "clojure"))
+                                    (concat cmd " -M"))
+  "Clojure CLI command used by the Clojure `clojure-cli' backend."
+  :type 'string
+  :group 'org-babel
+  :package-version '(Org . "9.7"))
+
+(defun org-babel-expand-body:clojure (body params &optional cljs-p)
+  "Expand BODY according to PARAMS, return the expanded body.
+When CLJS-P is non-nil, expand in a cljs context instead of clj."
   (let* ((vars (org-babel--get-vars params))
          (backend-override (cdr (assq :backend params)))
          (org-babel-clojure-backend
@@ -146,10 +170,26 @@ or set the `:backend' header argument"))))
                            vars
                            "\n      ")
                           body))))))
-    (if (or (member "code" result-params)
-           (member "pp" result-params))
-       (format "(clojure.pprint/pprint (do %s))" body)
-      body)))
+    ;; If the result param is set to "output" we don't have to do
+    ;; anything special and just let the backend handle everything
+    (if (member "output" result-params)
+        body
+
+      ;; If the result is not "output" (i.e. it's "value"), disable
+      ;; stdout output and print the last returned value.  Use pprint
+      ;; instead of prn when results param is "pp" or "code".
+      (concat
+       (if (or (member "code" result-params)
+              (member "pp" result-params))
+           (concat (if cljs-p
+                       "(require '[cljs.pprint :refer [pprint]])"
+                     "(require '[clojure.pprint :refer [pprint]])")
+                   " (pprint ")
+         "(prn ")
+       (if cljs-p
+           "(binding [cljs.core/*print-fn* (constantly nil)]"
+         "(binding [*out* (java.io.StringWriter.)]")
+       body "))"))))
 
 (defvar ob-clojure-inf-clojure-filter-out)
 (defvar ob-clojure-inf-clojure-tmp-output)
@@ -225,32 +265,19 @@ or set the `:backend' header argument"))))
                s))
            (reverse ob-clojure-inf-clojure-tmp-output)))))
 
-(defun ob-clojure-eval-with-cider (expanded params)
-  "Evaluate EXPANDED code block with PARAMS using cider."
+(defun ob-clojure-eval-with-cider (expanded params &optional cljs-p)
+  "Evaluate EXPANDED code block with PARAMS using cider.
+When CLJS-P is non-nil, use a cljs connection instead of clj."
   (org-require-package 'cider "Cider")
-  (let ((connection (cider-current-connection (cdr (assq :target params))))
-       (result-params (cdr (assq :result-params params)))
-       result0)
+  (let ((connection (cider-current-connection (if cljs-p "cljs" "clj"))))
     (unless connection (sesman-start-session 'CIDER))
     (if (not connection)
        ;; Display in the result instead of using `user-error'
-       (setq result0 "Please reevaluate when nREPL is connected")
-      (ob-clojure-with-temp-expanded expanded params
-       (let ((response (nrepl-sync-request:eval exp connection)))
-         (push (or (nrepl-dict-get response "root-ex")
-                   (nrepl-dict-get response "ex")
-                   (nrepl-dict-get
-                    response (if (or (member "output" result-params)
-                                     (member "pp" result-params))
-                                 "out"
-                               "value")))
-               result0)))
-      (ob-clojure-string-or-list
-       ;; Filter out s-expressions that return nil (string "nil"
-       ;; from nrepl eval) or comment forms (actual nil from nrepl)
-       (reverse (delete "" (mapcar (lambda (r)
-                                    (replace-regexp-in-string "nil" "" (or r 
"")))
-                                  result0)))))))
+        "Please reevaluate when nREPL is connected"
+      (let ((response (nrepl-sync-request:eval expanded connection)))
+        (or (nrepl-dict-get response "root-ex")
+           (nrepl-dict-get response "ex")
+           (nrepl-dict-get response "out"))))))
 
 (defun ob-clojure-eval-with-slime (expanded params)
   "Evaluate EXPANDED code block with PARAMS using slime."
@@ -262,39 +289,54 @@ or set the `:backend' header argument"))))
        ,(buffer-substring-no-properties (point-min) (point-max)))
      (cdr (assq :package params)))))
 
-(defun ob-clojure-eval-with-babashka (bb expanded)
-  "Evaluate EXPANDED code block using BB (babashka or nbb)."
-  (let ((script-file (org-babel-temp-file "clojure-bb-script-" ".clj")))
+(defun ob-clojure-eval-with-cmd (cmd expanded)
+  "Evaluate EXPANDED code block using CMD (babashka, clojure or nbb)."
+  (let ((script-file (org-babel-temp-file "clojure-cmd-script-" ".clj")))
     (with-temp-file script-file
       (insert expanded))
     (org-babel-eval
-     (format "%s %s" bb (org-babel-process-file-name script-file))
+     (format "%s %s" cmd (org-babel-process-file-name script-file))
      "")))
 
-(defun org-babel-execute:clojure (body params)
-  "Execute the BODY block of Clojure code with PARAMS using Babel."
+(defun org-babel-execute:clojure (body params &optional cljs-p)
+  "Execute the BODY block of Clojure code with PARAMS using Babel.
+When CLJS-P is non-nil, execute with a ClojureScript backend
+instead of Clojure."
   (let* ((backend-override (cdr (assq :backend params)))
          (org-babel-clojure-backend
           (cond
            (backend-override (intern backend-override))
-           (org-babel-clojure-backend org-babel-clojure-backend)
-           (t (user-error "You need to customize `org-babel-clojure-backend'
-or set the `:backend' header argument")))))
-    (let* ((expanded (org-babel-expand-body:clojure body params))
+           (org-babel-clojure-backend (if cljs-p
+                                          org-babel-clojurescript-backend
+                                        org-babel-clojure-backend))
+           (t (user-error "You need to customize `%S'
+or set the `:backend' header argument"
+                          (if cljs-p
+                              org-babel-clojurescript-backend
+                            org-babel-clojure-backend)))))
+         ;; We allow a Clojure source block to be evaluated with the
+         ;; nbb backend and therefore have to expand the body with
+         ;; ClojureScript syntax when we either evaluate a
+         ;; ClojureScript source block or use the nbb backend.
+         (cljs-p (or cljs-p (eq org-babel-clojure-backend 'nbb))))
+    (let* ((expanded (org-babel-expand-body:clojure body params cljs-p))
           (result-params (cdr (assq :result-params params)))
           result)
       (setq result
            (cond
             ((eq org-babel-clojure-backend 'inf-clojure)
              (ob-clojure-eval-with-inf-clojure expanded params))
+             ((eq org-babel-clojure-backend 'clojure-cli)
+              (ob-clojure-eval-with-cmd ob-clojure-cli-command expanded))
              ((eq org-babel-clojure-backend 'babashka)
-             (ob-clojure-eval-with-babashka ob-clojure-babashka-command 
expanded))
+             (ob-clojure-eval-with-cmd ob-clojure-babashka-command expanded))
              ((eq org-babel-clojure-backend 'nbb)
-             (ob-clojure-eval-with-babashka ob-clojure-nbb-command expanded))
+             (ob-clojure-eval-with-cmd ob-clojure-nbb-command expanded))
             ((eq org-babel-clojure-backend 'cider)
-             (ob-clojure-eval-with-cider expanded params))
+             (ob-clojure-eval-with-cider expanded params cljs-p))
             ((eq org-babel-clojure-backend 'slime)
-             (ob-clojure-eval-with-slime expanded params))))
+             (ob-clojure-eval-with-slime expanded params))
+             (t (user-error "Invalid backend"))))
       (org-babel-result-cond result-params
         result
         (condition-case nil (org-babel-script-escape result)
@@ -302,7 +344,7 @@ or set the `:backend' header argument")))))
 
 (defun org-babel-execute:clojurescript (body params)
   "Evaluate BODY with PARAMS as ClojureScript code."
-  (org-babel-execute:clojure body (cons '(:target . "cljs") params)))
+  (org-babel-execute:clojure body params t))
 
 (provide 'ob-clojure)
 
diff --git a/lisp/org-compat.el b/lisp/org-compat.el
index fadb51df62..c47a4e8c2a 100644
--- a/lisp/org-compat.el
+++ b/lisp/org-compat.el
@@ -71,6 +71,7 @@
 (declare-function outline-next-heading "outline" ())
 (declare-function speedbar-line-directory "speedbar" (&optional depth))
 (declare-function table--at-cell-p "table" (position &optional object 
at-column))
+(declare-function ob-clojure-eval-with-cmd "ob-clojure" (cmd expanded))
 (declare-function org-fold-folded-p "org-fold" (&optional pos spec-or-alias))
 (declare-function org-fold-hide-sublevels "org-fold" (levels))
 (declare-function org-fold-hide-subtree "org-fold" ())
@@ -1127,6 +1128,9 @@ context.  See the individual commands for more 
information."
  "Only the built-in Python mode is supported in ob-python now."
  "9.7")
 
+(define-obsolete-function-alias 'ob-clojure-eval-with-babashka
+  #'ob-clojure-eval-with-cmd "9.7")
+
 ;;;; Obsolete link types
 
 (eval-after-load 'ol