lisp/ob-clojure.el

   1 ;;; ob-clojure.el --- org-babel functions for clojure evaluation
   2
   3 ;; Copyright (C) 2009, 2010  Free Software Foundation, Inc.
   4
   5 ;; Author: Joel Boehland
   6 ;; Keywords: literate programming, reproducible research
   7 ;; Homepage: http://orgmode.org
   8 ;; Version: 0.01
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software: you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation, either version 3 of the License, or
  15 ;; (at your option) any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
  24
  25 ;;; Commentary:
  26
  27 ;;; ob support for evaluating clojure code
  28
  29 ;;; Requirements:
  30
  31 ;;; A working clojure install. This also implies a working java executable
  32 ;;; clojure-mode
  33 ;;; slime
  34 ;;; swank-clojure
  35
  36 ;;; By far, the best way to install these components is by following
  37 ;;; the directions as set out by Phil Hagelberg (Technomancy) on the
  38 ;;; web page: http://technomancy.us/126
  39
  40 ;;; Code:
  41 (require 'ob)
  42 (require 'ob-eval)
  43 (eval-when-compile (require 'cl))
  44
  45 (declare-function slime-eval-async "ext:slime" (sexp &optional cont package))
  46 (declare-function slime-eval "ext:slime" (sexp &optional package))
  47 (declare-function swank-clojure-concat-paths "ext:slime" (paths))
  48 (declare-function org-babel-ref-variables "ext:slime" (params))
  49 (declare-function slime "ext:slime" (&optional command coding-system))
  50 (declare-function slime-output-buffer "ext:slime" (&optional noprompt))
  51 (declare-function slime-filter-buffers "ext:slime" (predicate))
  52
  53 (add-to-list 'org-babel-tangle-lang-exts '("clojure" . "clj"))
  54
  55 (defvar org-babel-default-header-args:clojure '())
  56
  57 (defvar org-babel-clojure-wrapper-method
  58   "
  59 (defn spit
  60   [f content]
  61   (with-open [#^java.io.PrintWriter w
  62                  (java.io.PrintWriter.
  63                    (java.io.BufferedWriter.
  64                      (java.io.OutputStreamWriter.
  65                        (java.io.FileOutputStream.
  66                          (java.io.File. f)))))]
  67       (.print w content)))
  68
  69 (defn main
  70   []
  71   %s)
  72
  73 (spit \"%s\" (str (main)))")
  74 ;;";; <-- syntax highlighting is messed without this double quote
  75
  76 ;;taken mostly from clojure-test-mode.el
  77 (defun org-babel-clojure-clojure-slime-eval (string &optional handler)
  78   "Evaluate a STRING of clojure code using `slime-eval-async'."
  79   (slime-eval-async `(swank:eval-and-grab-output ,string)
  80                     (or handler #'identity)))
  81
  82 (defun org-babel-clojure-slime-eval-sync (string)
  83   "Evaluate a STRING of clojure code using `slime-eval'."
  84   (slime-eval `(swank:eval-and-grab-output ,string)))
  85
  86 ;;taken from swank-clojure.el
  87 (defvar swank-clojure-binary)
  88 (defvar swank-clojure-classpath)
  89 (defvar swank-clojure-java-path)
  90 (defvar swank-clojure-extra-vm-args)
  91 (defvar swank-clojure-library-paths)
  92 (defvar swank-clojure-extra-classpaths)
  93 (defun org-babel-clojure-babel-clojure-cmd ()
  94   "Create the command to start clojure according to current settings."
  95   (if (and (not swank-clojure-binary) (not swank-clojure-classpath))
  96       (error "%s" (concat "You must specifiy either a `swank-clojure-binary' "
  97                           "or a `swank-clojure-jar-path'"))
  98     (if swank-clojure-binary
  99         (if (listp swank-clojure-binary)
 100             swank-clojure-binary
 101           (list swank-clojure-binary))
 102       (delq
 103        nil
 104        (append
 105         (list swank-clojure-java-path)
 106         swank-clojure-extra-vm-args
 107         (list
 108          (when swank-clojure-library-paths
 109            (concat "-Djava.library.path="
 110                    (swank-clojure-concat-paths swank-clojure-library-paths)))
 111          "-classpath"
 112          (swank-clojure-concat-paths
 113           (append
 114            swank-clojure-classpath
 115            swank-clojure-extra-classpaths))
 116          "clojure.main"))))))
 117
 118 (defun org-babel-clojure-table-or-string (results)
 119   "If RESULTS looks like a table, then convert them into an
 120 Emacs-lisp table, otherwise return the results as a string."
 121   (org-babel-read
 122    (if (string-match "^\\[.+\\]$" results)
 123        (org-babel-read
 124         (concat "'"
 125                 (replace-regexp-in-string
 126                  "\\[" "(" (replace-regexp-in-string
 127                             "\\]" ")" (replace-regexp-in-string
 128                                        ", " " " (replace-regexp-in-string
 129                                                  "'" "\"" results))))))
 130      results)))
 131
 132 (defun org-babel-clojure-var-to-clojure (var)
 133   "Convert an elisp var into a string of clojure source code
 134 specifying a var of the same value."
 135   (if (listp var)
 136       (format "'%s" var)
 137     (format "%S" var)))
 138
 139 (defun org-babel-clojure-build-full-form (body vars)
 140   "Construct a clojure let form with vars as the let vars."
 141   (let ((vars-forms
 142          (mapconcat ;; define any variables
 143           (lambda (pair)
 144             (format "%s %s"
 145                     (car pair) (org-babel-clojure-var-to-clojure (cdr pair))))
 146           vars "\n      "))
 147         (body (org-babel-trim body)))
 148     (if (> (length vars-forms) 0)
 149         (format "(let [%s]\n  %s)" vars-forms body)
 150       body)))
 151
 152 (defun org-babel-prep-session:clojure (session params)
 153   "Prepare SESSION according to the header arguments specified in PARAMS."
 154   (require 'slime) (require 'swank-clojure)
 155   (let* ((session-buf (org-babel-clojure-initiate-session session))
 156          (vars (org-babel-ref-variables params))
 157          (var-lines (mapcar ;; define any top level session variables
 158                      (lambda (pair)
 159                        (format "(def %s %s)\n" (car pair)
 160                                (org-babel-clojure-var-to-clojure (cdr pair))))
 161                      vars)))
 162     session-buf))
 163
 164 (defun org-babel-load-session:clojure (session body params)
 165   "Load BODY into SESSION."
 166   (require 'slime) (require 'swank-clojure)
 167   (save-window-excursion
 168     (let ((buffer (org-babel-prep-session:clojure session params)))
 169       (with-current-buffer buffer
 170         (goto-char (point-max))
 171         (insert (org-babel-chomp body)))
 172       buffer)))
 173
 174 (defvar org-babel-clojure-buffers '())
 175 (defvar org-babel-clojure-pending-sessions '())
 176
 177 (defun org-babel-clojure-session-buffer (session)
 178   "Return the buffer associated with SESSION."
 179   (cdr (assoc session org-babel-clojure-buffers)))
 180
 181 (defun org-babel-clojure-initiate-session-by-key (&optional session)
 182   "If there is not a current inferior-process-buffer in SESSION
 183 then create one.  Return the initialized session."
 184   (save-window-excursion
 185     (let* ((session (if session
 186                         (if (stringp session) (intern session)
 187                           session)
 188                       :default))
 189            (clojure-buffer (org-babel-clojure-session-buffer session)))
 190       (unless (and clojure-buffer (buffer-live-p clojure-buffer))
 191         (setq org-babel-clojure-buffers
 192               (assq-delete-all session org-babel-clojure-buffers))
 193         (push session org-babel-clojure-pending-sessions)
 194         (slime)
 195         ;; we are waiting to finish setting up which will be done in
 196         ;; org-babel-clojure-session-connected-hook below.
 197         (let ((timeout 9))
 198           (while (and (not (org-babel-clojure-session-buffer session))
 199                       (< 0 timeout))
 200             (message "Waiting for clojure repl for session: %s ... %i"
 201                      session timeout)
 202             (sit-for 1)
 203             (decf timeout)))
 204         (setq org-babel-clojure-pending-sessions
 205               (remove session org-babel-clojure-pending-sessions))
 206         (unless (org-babel-clojure-session-buffer session)
 207           (error "Couldn't create slime clojure process"))
 208         (setq clojure-buffer (org-babel-clojure-session-buffer session)))
 209       session)))
 210
 211 (defun org-babel-clojure-initiate-session (&optional session params)
 212   "Return the slime-clojure repl buffer bound to this session
 213 or nil if \"none\" is specified."
 214   (require 'slime) (require 'swank-clojure)
 215   (unless (and (stringp session) (string= session "none"))
 216     (org-babel-clojure-session-buffer
 217      (org-babel-clojure-initiate-session-by-key session))))
 218
 219 (defun org-babel-clojure-session-connected-hook ()
 220   "Finish setting up the bindings of org-babel session to a slime-clojure repl."
 221   (let ((pending-session (pop org-babel-clojure-pending-sessions)))
 222     (when pending-session
 223       (save-excursion
 224         (switch-to-buffer (slime-output-buffer))
 225         (rename-buffer
 226          (if (stringp pending-session)
 227              pending-session (symbol-name pending-session)))
 228         (org-babel-clojure-bind-session-to-repl-buffer
 229          pending-session (slime-output-buffer))))))
 230
 231 (add-hook 'slime-connected-hook 'org-babel-clojure-session-connected-hook)
 232
 233 (defun org-babel-clojure-bind-session-to-repl-buffer (session repl-buffer)
 234   "Associate SESSION with REPL-BUFFER."
 235   (when (stringp session) (setq session (intern session)))
 236   (setq org-babel-clojure-buffers
 237         (cons (cons session repl-buffer)
 238               (assq-delete-all session org-babel-clojure-buffers))))
 239
 240 (defun org-babel-clojure-repl-buffer-pred ()
 241   "Test whether the current buffer is an active slime-clojure
 242 repl buffer."
 243   (and (buffer-live-p (current-buffer)) (eq major-mode 'slime-repl-mode)))
 244
 245 (defun org-babel-clojure-bind-session-to-repl (session)
 246   "Bind SESSION to a clojure repl."
 247   (interactive "sEnter session name: ")
 248   (let ((repl-bufs (slime-filter-buffers 'org-babel-clojure-repl-buffer-pred)))
 249     (unless repl-bufs (error "No existing slime-clojure repl buffers exist"))
 250     (let ((repl-buf (read-buffer "Choose slime-clojure repl: " repl-bufs t)))
 251       (org-babel-clojure-bind-session-to-repl-buffer session repl-buf))))
 252
 253 (defun org-babel-clojure-evaluate-external-process
 254   (buffer body &optional result-type)
 255   "Evaluate the body in an external process."
 256   (let ((cmd (format "%s -" (mapconcat #'identity
 257                                        (org-babel-clojure-babel-clojure-cmd)
 258                                        " "))))
 259     (case result-type
 260       (output (org-babel-eval cmd body))
 261       (value (let* ((tmp-file (make-temp-file "org-babel-clojure-results-")))
 262                (org-babel-eval cmd (format org-babel-clojure-wrapper-method
 263                                            body tmp-file tmp-file))
 264                (org-babel-clojure-table-or-string
 265                 (org-babel-eval-read-file tmp-file)))))))
 266
 267 (defun org-babel-clojure-evaluate-session (buffer body &optional result-type)
 268   "Evaluate the body in the context of a clojure session."
 269   (require 'slime) (require 'swank-clojure)
 270   (let ((raw nil)
 271         (results nil))
 272     (with-current-buffer buffer
 273       (setq raw (org-babel-clojure-slime-eval-sync body))
 274       (setq results (reverse (mapcar #'org-babel-trim raw)))
 275       (cond
 276        ((equal result-type 'output)
 277         (mapconcat #'identity (reverse (cdr results)) "\n"))
 278        ((equal result-type 'value)
 279         (org-babel-clojure-table-or-string (car results)))))))
 280
 281 (defun org-babel-clojure-evaluate (buffer body &optional result-type)
 282   "Pass BODY to the Clojure process in BUFFER.  If RESULT-TYPE equals
 283 'output then return a list of the outputs of the statements in
 284 BODY, if RESULT-TYPE equals 'value then return the value of the
 285 last statement in BODY, as elisp."
 286   (if buffer
 287       (org-babel-clojure-evaluate-session buffer body result-type)
 288     (org-babel-clojure-evaluate-external-process buffer body result-type)))
 289
 290 (defun org-babel-expand-body:clojure (body params &optional processed-params)
 291   "Expand BODY according to PARAMS, return the expanded body."
 292   (org-babel-clojure-build-full-form
 293    body (nth 1 (or processed-params (org-babel-process-params params)))))
 294
 295 (defun org-babel-execute:clojure (body params)
 296   "Execute a block of Clojure code with org-babel."
 297   (require 'slime) (require 'swank-clojure)
 298   (let* ((processed-params (org-babel-process-params params))
 299          (body (org-babel-expand-body:clojure body params processed-params))
 300          (session (org-babel-clojure-initiate-session
 301                    (first processed-params))))
 302     (org-babel-reassemble-table
 303      (org-babel-clojure-evaluate session body (nth 3 processed-params))
 304      (org-babel-pick-name
 305       (nth 4 processed-params) (cdr (assoc :colnames params)))
 306      (org-babel-pick-name
 307       (nth 5 processed-params) (cdr (assoc :rownames params))))))
 308
 309 (provide 'ob-clojure)
 310
 311 ;; arch-tag: a43b33f2-653e-46b1-ac56-2805cf05b7d1
 312
 313 ;;; ob-clojure.el ends here