[elpa] externals/org bf1c4c7 22/85: Include support for evaluating julia code

[ELPA Syncer]

branch: externals/org
commit bf1c4c7575e9aff11f1e20e5692678be7eeb49a5
Author: Pedro Bruel <pedro.bruel@gmail.com>
Commit: Bastien <bzg@gnu.org>

    Include support for evaluating julia code
    
    * lisp/ob-julia.el: included from org-contrib
    * testing/lisp/test-ob-julia.el: start adapting from 
testing/lisp/test-ob-python.el
---
 lisp/ob-julia.el              | 344 ++++++++++++++++++++++++++++++++++++++++++
 testing/lisp/test-ob-julia.el | 274 +++++++++++++++++++++++++++++++++
 2 files changed, 618 insertions(+)

diff --git a/lisp/ob-julia.el b/lisp/ob-julia.el
new file mode 100644
index 0000000..cbc58d6
--- /dev/null
+++ b/lisp/ob-julia.el
@@ -0,0 +1,344 @@
+;;; ob-julia.el --- org-babel functions for julia code evaluation
+
+;; Copyright (C) 2013, 2014, 2021 G. Jay Kerns
+;; Authors: G. Jay Kerns, based on ob-R.el by Eric Schulte and Dan Davison
+;; Maintainer: Pedro Bruel <pedro.bruel@gmail.com>
+;; Keywords: literate programming, reproducible research, scientific computing
+;; Homepage: https://github.com/phrb/ob-julia
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Org-Babel support for evaluating julia code
+
+;;; Code:
+(require 'cl-lib)
+(require 'ob)
+
+(declare-function orgtbl-to-csv "org-table" (table params))
+(declare-function julia "ext:ess-julia" (&optional start-args))
+(declare-function inferior-ess-send-input "ext:ess-inf" ())
+(declare-function ess-make-buffer-current "ext:ess-inf" ())
+(declare-function ess-eval-buffer "ext:ess-inf" (vis))
+(declare-function ess-wait-for-process "ext:ess-inf"
+                 (&optional proc sec-prompt wait force-redisplay))
+
+(defvar org-babel-header-args:julia
+  '((width              . :any)
+    (horizontal                 . :any)
+    (results             . ((file list vector table scalar verbatim)
+                           (raw org html latex code pp wrap)
+                           (replace silent append prepend)
+                           (output value graphics))))
+  "julia-specific header arguments.")
+
+(add-to-list 'org-babel-tangle-lang-exts '("julia" . "jl"))
+
+(defvar org-babel-default-header-args:julia '())
+
+(defcustom org-babel-julia-command "julia"
+  "Name of command to use for executing julia code."
+  :version "24.3"
+  :package-version '(Org . "8.0")
+  :group 'org-babel
+  :type 'string)
+
+(defvar ess-current-process-name) ; dynamically scoped
+(defvar ess-local-process-name) ; dynamically scoped
+(defun org-babel-edit-prep:julia (info)
+  (let ((session (cdr (assq :session (nth 2 info)))))
+    (when (and session
+              (string-prefix-p "*"  session)
+              (string-suffix-p "*" session))
+      (org-babel-julia-initiate-session session nil))))
+
+(defun org-babel-expand-body:julia (body params &optional _graphics-file)
+  "Expand BODY according to PARAMS, return the expanded body."
+  (mapconcat 'identity
+            (append
+             (when (cdr (assq :prologue params))
+               (list (cdr (assq :prologue params))))
+             (org-babel-variable-assignments:julia params)
+             (list body)
+             (when (cdr (assq :epilogue params))
+               (list (cdr (assq :epilogue params)))))
+            "\n"))
+
+(defun org-babel-execute:julia (body params)
+  "Execute a block of julia code.
+This function is called by `org-babel-execute-src-block'."
+  (save-excursion
+    (let* ((result-params (cdr (assq :result-params params)))
+          (result-type (cdr (assq :result-type params)))
+           (session (org-babel-julia-initiate-session
+                    (cdr (assq :session params)) params))
+          (graphics-file (and (member "graphics" (assq :result-params params))
+                              (org-babel-graphical-output-file params)))
+          (colnames-p (unless graphics-file (cdr (assq :colnames params))))
+          (rownames-p (unless graphics-file (cdr (assq :rownames params))))
+          (full-body (org-babel-expand-body:julia body params graphics-file))
+          (result
+           (org-babel-julia-evaluate
+            session full-body result-type result-params
+            (or (equal "yes" colnames-p)
+                (org-babel-pick-name
+                 (cdr (assq :colname-names params)) colnames-p))
+            (or (equal "yes" rownames-p)
+                (org-babel-pick-name
+                 (cdr (assq :rowname-names params)) rownames-p)))))
+      (if graphics-file nil result))))
+
+(defun org-babel-normalize-newline (result)
+  (replace-regexp-in-string
+   "\\(\n\r?\\)\\{2,\\}"
+   "\n"
+   result))
+
+(defun org-babel-prep-session:julia (session params)
+  "Prepare SESSION according to the header arguments specified in PARAMS."
+  (let* ((session (org-babel-julia-initiate-session session params))
+        (var-lines (org-babel-variable-assignments:julia params)))
+    (org-babel-comint-in-buffer session
+      (mapc (lambda (var)
+              (end-of-line 1) (insert var) (comint-send-input nil t)
+              (org-babel-comint-wait-for-output session)) var-lines))
+    session))
+
+(defun org-babel-load-session:julia (session body params)
+  "Load BODY into SESSION."
+  (save-window-excursion
+    (let ((buffer (org-babel-prep-session:julia session params)))
+      (with-current-buffer buffer
+        (goto-char (process-mark (get-buffer-process (current-buffer))))
+        (insert (org-babel-chomp body)))
+      buffer)))
+
+;; helper functions
+
+(defun org-babel-variable-assignments:julia (params)
+  "Return list of julia statements assigning the block's variables."
+  (let ((vars (org-babel--get-vars params)))
+    (mapcar
+     (lambda (pair)
+       (org-babel-julia-assign-elisp
+       (car pair) (cdr pair)
+       (equal "yes" (cdr (assq :colnames params)))
+       (equal "yes" (cdr (assq :rownames params)))))
+     (mapcar
+      (lambda (i)
+       (cons (car (nth i vars))
+             (org-babel-reassemble-table
+              (cdr (nth i vars))
+              (cdr (nth i (cdr (assq :colname-names params))))
+              (cdr (nth i (cdr (assq :rowname-names params)))))))
+      (number-sequence 0 (1- (length vars)))))))
+
+(defun org-babel-julia-quote-csv-field (s)
+  "Quote field S for export to julia."
+  (if (stringp s)
+      (concat "\"" (mapconcat 'identity (split-string s "\"") "\"\"") "\"")
+    (format "%S" s)))
+
+(defun org-babel-julia-assign-elisp (name value colnames-p rownames-p)
+  "Construct julia code assigning the elisp VALUE to a variable named NAME."
+  (if (listp value)
+      (let* ((lengths (mapcar 'length (cl-remove-if-not 'sequencep value)))
+             (max (if lengths (apply 'max lengths) 0))
+             (min (if lengths (apply 'min lengths) 0)))
+        ;; Ensure VALUE has an orgtbl structure (depth of at least 2).
+        (unless (listp (car value)) (setq value (list value)))
+        (let ((file (orgtbl-to-csv value '(:fmt 
org-babel-julia-quote-csv-field)))
+              (header (if (or (eq (nth 1 value) 'hline) colnames-p)
+                          "TRUE" "FALSE"))
+              (row-names (if rownames-p "1" "NULL")))
+          (if (= max min)
+              (format "%s = begin
+    using CSV
+    CSV.read(\"%s\")
+end" name file)
+            (format "%s = begin
+    using CSV
+    CSV.read(\"%s\")
+end"
+                    name file))))
+    (format "%s = %s" name (org-babel-julia-quote-csv-field value))))
+
+(defvar ess-ask-for-ess-directory) ; dynamically scoped
+(defun org-babel-julia-initiate-session (session params)
+  "If there is not a current julia process then create one."
+  (unless (string= session "none")
+    (let ((session (or session "*Julia*"))
+         (ess-ask-for-ess-directory
+          (and (boundp 'ess-ask-for-ess-directory)
+               ess-ask-for-ess-directory
+               (not (cdr (assq :dir params))))))
+      (if (org-babel-comint-buffer-livep session)
+         session
+       (save-window-excursion
+         (when (get-buffer session)
+           ;; Session buffer exists, but with dead process
+           (set-buffer session))
+          (require 'ess) (set-buffer (julia))
+         (rename-buffer
+          (if (bufferp session)
+              (buffer-name session)
+            (if (stringp session)
+                session
+              (buffer-name))))
+         (current-buffer))))))
+
+; (defun org-babel-julia-associate-session (session)
+;   "Associate julia code buffer with a julia session.
+; Make SESSION be the inferior ESS process associated with the
+; current code buffer."
+;   (setq ess-local-process-name
+;      (process-name (get-buffer-process session)))
+;   (ess-make-buffer-current))
+
+(defun org-babel-julia-graphical-output-file (params)
+  "Name of file to which julia should send graphical output."
+  (and (member "graphics" (cdr (assq :result-params params)))
+       (cdr (assq :file params))))
+
+(defconst org-babel-julia-eoe-indicator "print(\"org_babel_julia_eoe\")")
+(defconst org-babel-julia-eoe-output "org_babel_julia_eoe")
+
+(defconst org-babel-julia-write-object-command "begin
+    local p_ans = %s
+    local p_tmp_file = \"%s\"
+
+    try
+        using CSV, DataFrames
+
+        if typeof(p_ans) <: DataFrame
+           p_ans_df = p_ans
+        else
+            p_ans_df = DataFrame(:ans => p_ans)
+        end
+
+        CSV.write(p_tmp_file,
+                  p_ans_df,
+                  writeheader = %s,
+                  transform = (col, val) -> something(val, missing),
+                  missingstring = \"nil\",
+                  quotestrings = false)
+        p_ans
+    catch e
+        err_msg = \"Source block evaluation failed. $e\"
+        CSV.write(p_tmp_file,
+                  DataFrame(:ans => err_msg),
+                  writeheader = false,
+                  transform = (col, val) -> something(val, missing),
+                  missingstring = \"nil\",
+                  quotestrings = false)
+
+        err_msg
+    end
+end")
+
+(defun org-babel-julia-evaluate
+  (session body result-type result-params column-names-p row-names-p)
+  "Evaluate julia code in BODY."
+  (if session
+      (org-babel-julia-evaluate-session
+       session body result-type result-params column-names-p row-names-p)
+    (org-babel-julia-evaluate-external-process
+     body result-type result-params column-names-p row-names-p)))
+
+(defun org-babel-julia-evaluate-external-process
+  (body result-type result-params column-names-p row-names-p)
+  "Evaluate BODY in external julia process.
+If RESULT-TYPE equals 'output then return standard output as a
+string.  If RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (cl-case result-type
+    (value
+     (let ((tmp-file (org-babel-temp-file "julia-")))
+       (org-babel-eval org-babel-julia-command
+                      (format org-babel-julia-write-object-command
+                              (format "begin %s end" body)
+                              (org-babel-process-file-name tmp-file 'noquote)
+                               (if column-names-p "true" "false")
+                               ))
+       (org-babel-julia-process-value-result
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
+         (org-babel-import-elisp-from-file tmp-file '(4)))
+       column-names-p)))
+    (output (org-babel-eval org-babel-julia-command body))))
+
+(defun org-babel-julia-evaluate-session
+  (session body result-type result-params column-names-p row-names-p)
+  "Evaluate BODY in SESSION.
+If RESULT-TYPE equals 'output then return standard output as a
+string.  If RESULT-TYPE equals 'value then return the value of the
+last statement in BODY, as elisp."
+  (cl-case result-type
+    (value
+     (with-temp-buffer
+       (insert (org-babel-chomp body))
+       (let ((ess-local-process-name
+             (process-name (get-buffer-process session)))
+            (ess-eval-visibly-p nil))
+        (ess-eval-buffer nil)))
+     (let ((tmp-file (org-babel-temp-file "julia-")))
+       (org-babel-comint-eval-invisibly-and-wait-for-file
+       session tmp-file
+       (format org-babel-julia-write-object-command
+                "ans"
+               (org-babel-process-file-name tmp-file 'noquote)
+                (if column-names-p "true" "false")
+                ))
+       (org-babel-julia-process-value-result
+       (org-babel-result-cond result-params
+         (with-temp-buffer
+           (insert-file-contents tmp-file)
+           (buffer-string))
+         (org-babel-import-elisp-from-file tmp-file '(4)))
+       column-names-p)))
+    (output
+     (mapconcat
+      'org-babel-chomp
+      (butlast
+       (delq nil
+            (mapcar
+             (lambda (line) (when (> (length line) 0) line))
+             (mapcar
+              (lambda (line) ;; cleanup extra prompts left in output
+                (if (string-match
+                     "^\\([>+.]\\([ ][>.+]\\)*[ ]\\)"
+                     (car (split-string line "\n")))
+                    (substring line (match-end 1))
+                  line))
+              (org-babel-comint-with-output (session 
org-babel-julia-eoe-output)
+                (insert (mapconcat 'org-babel-chomp
+                                   (list body org-babel-julia-eoe-indicator)
+                                   "\n"))
+                 (inferior-ess-send-input)))))) "\n"))))
+
+(defun org-babel-julia-process-value-result (result column-names-p)
+  "julia-specific processing of return value.
+Insert hline if column names in output have been requested."
+  (if column-names-p
+      (cons (car result) (cons 'hline (cdr result)))
+    result))
+
+(provide 'ob-julia)
+
+;;; ob-julia.el ends here
diff --git a/testing/lisp/test-ob-julia.el b/testing/lisp/test-ob-julia.el
new file mode 100644
index 0000000..f6d2172
--- /dev/null
+++ b/testing/lisp/test-ob-julia.el
@@ -0,0 +1,274 @@
+;;; test-ob-python.el --- tests for ob-python.el
+
+;; Copyright (c) 2011-2014, 2019, 2021 Eric Schulte
+;; Authors: Pedro Bruel, based on test-ob-python.el by Eric Schulte
+;; Maintainer: Pedro Bruel <pedro.bruel@gmail.com>
+
+;; This file is not part of GNU Emacs.
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+;;; Code:
+(org-test-for-executable "julia")
+(unless (featurep 'ob-julia)
+  (signal 'missing-test-dependency "Support for julia code blocks"))
+
+(ert-deftest test-ob-julia/colnames-yes-header-argument ()
+  (should
+   (equal '(("col") hline ("a") ("b"))
+         (org-test-with-temp-text "#+name: eg
+| col |
+|-----|
+| a   |
+| b   |
+
+#+header: :colnames yes
+#+header: :var x = eg
+<point>#+begin_src julia
+return x
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/colnames-yes-header-argument-again ()
+  (should
+   (equal '(("a") hline ("b*") ("c*"))
+         (org-test-with-temp-text "#+name: less-cols
+| a |
+|---|
+| b |
+| c |
+
+#+header: :colnames yes
+<point>#+begin_src julia :var tab=less-cols
+  return [[val + '*' for val in row] for row in tab]
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/colnames-nil-header-argument ()
+  (should
+   (equal '(("col") hline ("a") ("b"))
+         (org-test-with-temp-text "#+name: eg
+| col |
+|-----|
+| a   |
+| b   |
+
+#+header: :colnames nil
+#+header: :var x = eg
+<point>#+begin_src julia
+return x
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/colnames-no-header-argument-again ()
+  (should
+   (equal '(("a*") ("b*") ("c*"))
+         (org-test-with-temp-text "#+name: less-cols
+| a |
+|---|
+| b |
+| c |
+
+#+header: :colnames no
+<point>#+begin_src julia :var tab=less-cols
+  return [[val + '*' for val in row] for row in tab]
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/colnames-no-header-argument ()
+  (should
+   (equal '(("col") ("a") ("b"))
+         (org-test-with-temp-text "#+name: eg
+| col |
+|-----|
+| a   |
+| b   |
+
+#+header: :colnames no
+#+header: :var x = eg
+<point>#+begin_src julia
+return x
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/session-multiline ()
+  (should
+   (equal "20"
+         (org-test-with-temp-text "#+begin_src julia :session :results output
+  foo = 0
+  for _ in range(10):
+      foo += 1
+
+      foo += 1
+
+  print(foo)
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest 
test-ob-julia/insert-necessary-blank-line-when-sending-code-to-interpreter ()
+  (should
+   (equal 2 (org-test-with-temp-text "#+begin_src julia :session :results value
+if True:
+    1
+2
+#+end_src"
+             ;; Previously, while adding `:session' to a normal code
+             ;; block, also need to add extra blank lines to end
+             ;; indent block or indicate logical sections. Now, the
+             ;; `org-babel-julia-evaluate-session' can do it
+             ;; automatically:
+             ;;
+             ;; >>> if True:
+             ;; >>>     1
+             ;; >>> <insert_blank_line_here>
+             ;; >>> 2
+             (org-babel-execute-maybe)
+             (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/if-else-block ()
+  (should
+   (equal "success" (org-test-with-temp-text "#+begin_src julia :session 
:results value
+value = 'failure'
+if False:
+    pass
+else:
+    value = 'success'
+value
+#+end_src"
+             (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/indent-block-with-blank-lines ()
+  (should
+   (equal 20
+         (org-test-with-temp-text "#+begin_src julia :session :results value
+  foo = 0
+  for i in range(10):
+      foo += 1
+
+      foo += 1
+
+  foo
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/assign-underscore ()
+  (should
+   (equal "success"
+         (org-test-with-temp-text "#+begin_src julia :session :results value
+_ = 'failure'
+'success'
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/multiline-var ()
+  (should
+   (equal "a\nb\nc"
+         (org-test-with-temp-text "#+begin_src julia :var text=\"a\\nb\\nc\"
+return text
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/multiline-str ()
+  (should
+   (equal "a\nb\nc"
+         (org-test-with-temp-text "#+begin_src julia
+text=\"a\\nb\\nc\"
+return text
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/header-var-assignment ()
+  (should
+   (equal "success"
+         (org-test-with-temp-text "#+begin_src julia :var text=\"failure\"
+text
+text=\"success\"
+return text
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/session-value-sleep ()
+  (should
+   (equal "success"
+         (org-test-with-temp-text "#+begin_src julia :session :results value
+import time
+time.sleep(.1)
+'success'
+#+end_src"
+           (org-babel-execute-src-block)))))
+
+(ert-deftest test-ob-julia/async-simple-session-output ()
+  (let ((org-babel-temporary-directory temporary-file-directory)
+        (org-confirm-babel-evaluate nil))
+    (org-test-with-temp-text
+     "#+begin_src julia :session :async yes :results output
+import time
+time.sleep(.1)
+print('Yep!')
+#+end_src\n"
+     (should (let ((expected "Yep!"))
+              (and (not (string= expected (org-babel-execute-src-block)))
+                   (string= expected
+                            (progn
+                              (sleep-for 0 200)
+                              (goto-char (org-babel-where-is-src-block-result))
+                              (org-babel-read-result)))))))))
+
+(ert-deftest test-ob-julia/async-named-output ()
+  (let (org-confirm-babel-evaluate
+        (org-babel-temporary-directory temporary-file-directory)
+        (src-block "#+begin_src julia :async :session :results output
+print(\"Yep!\")
+#+end_src")
+        (results-before "
+
+#+NAME: foobar
+#+RESULTS:
+: Nope!")
+        (results-after "
+
+#+NAME: foobar
+#+RESULTS:
+: Yep!
+"))
+    (org-test-with-temp-text
+     (concat src-block results-before)
+     (should (progn (org-babel-execute-src-block)
+                    (sleep-for 0 200)
+                    (string= (concat src-block results-after)
+                             (buffer-string)))))))
+
+(ert-deftest test-ob-julia/async-output-drawer ()
+  (let (org-confirm-babel-evaluate
+        (org-babel-temporary-directory temporary-file-directory)
+        (src-block "#+begin_src julia :async :session :results output drawer
+print(list(range(3)))
+#+end_src")
+        (result "
+
+#+RESULTS:
+:results:
+[0, 1, 2]
+:end:
+"))
+    (org-test-with-temp-text
+     src-block
+     (should (progn (org-babel-execute-src-block)
+                    (sleep-for 0 200)
+                    (string= (concat src-block result)
+                             (buffer-string)))))))
+
+(provide 'test-ob-julia)
+
+;;; test-ob-julia.el ends here