123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219 |
- ;;; org-babel-ref.el --- org-babel functions for referencing external data
- ;; Copyright (C) 2009 Eric Schulte, Dan Davison
- ;; Author: Eric Schulte, Dan Davison
- ;; Keywords: literate programming, reproducible research
- ;; Homepage: http://orgmode.org
- ;; Version: 0.01
- ;;; License:
- ;; 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, 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 GNU Emacs; see the file COPYING. If not, write to the
- ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- ;; Boston, MA 02110-1301, USA.
- ;;; Commentary:
- ;; Functions for referencing data from the header arguments of a
- ;; org-babel block. The syntax of such a reference should be
- ;;
- ;; #+VAR: variable-name=file:resource-id
- ;;
- ;; - variable-name :: the name of the variable to which the value
- ;; will be assigned
- ;;
- ;; - file :: path to the file containing the resource, or omitted if
- ;; resource is in the current file
- ;;
- ;; - resource-id :: the id or name of the resource
- ;;
- ;; So an example of a simple src block referencing table data in the
- ;; same file would be
- ;;
- ;; #+TBLNAME: sandbox
- ;; | 1 | 2 | 3 |
- ;; | 4 | org-babel | 6 |
- ;;
- ;; #+begin_src emacs-lisp :var table=sandbox
- ;; (message table)
- ;; #+end_src
- ;;
- ;;; Code:
- (require 'org-babel)
- (defun org-babel-ref-variables (params)
- "Takes a parameter alist, and return an alist of variable
- names, and the emacs-lisp representation of the related value."
- (let ((assignments
- (delq nil (mapcar (lambda (pair) (if (eq (car pair) :var) (cdr pair))) params)))
- (others
- (delq nil (mapcar (lambda (pair) (unless (eq :var (car pair)) pair)) params))))
- (mapcar (lambda (assignment) (org-babel-ref-parse assignment)) assignments)))
- (defvar org-babel-ref-split-regexp
- "[ \f\t\n\r\v]*\\(.+?\\)[ \f\t\n\r\v]*=[ \f\t\n\r\v]*\\(.+\\)[ \f\t\n\r\v]*")
- (defun org-babel-ref-parse (assignment &optional params)
- "Parse a variable ASSIGNMENT in a header argument. If the
- right hand side of the assignment has a literal value return that
- value, otherwise interpret as a reference to an external resource
- and find it's value using `org-babel-ref-resolve-reference'.
- Return a list with two elements. The first element of the list
- will be the name of the variable, and the second will be an
- emacs-lisp representation of the value of the variable."
- (if (string-match org-babel-ref-split-regexp assignment)
- (let ((var (match-string 1 assignment))
- (ref (match-string 2 assignment)))
- (cons (intern var)
- (or (org-babel-ref-literal ref)
- (org-babel-ref-resolve-reference ref params))))))
- (defun org-babel-ref-literal (ref)
- "Determine if the right side of a header argument variable
- assignment is a literal value or is a reference to some external
- resource. REF should be a string of the right hand side of the
- assignment. If REF is literal then return it's value, otherwise
- return nil."
- (let ((out (org-babel-read ref)))
- (if (equal out ref)
- (if (string-match "^\".+\"$" ref)
- (read ref))
- out)))
- (defun org-babel-ref-resolve-reference (ref &optional params)
- "Resolve the reference and return its value"
- (save-excursion
- (let ((case-fold-search t)
- type args new-refere new-referent result lob-info split-file split-ref
- index index-row index-col)
- ;; if ref is indexed grab the indices -- beware nested indicies
- (when (and (string-match "\\[\\(.+\\)\\]" ref)
- (let ((str (substring ref 0 (match-beginning 0))))
- (= (count ?( str) (count ?) str))))
- (setq index (match-string 1 ref))
- (setq ref (substring ref 0 (match-beginning 0))))
- ;; assign any arguments to pass to source block
- (when (string-match "^\\(.+?\\)\(\\(.*\\)\)$" ref)
- (setq new-refere (match-string 1 ref))
- (setq new-referent (match-string 2 ref))
- ;; (message "new-refere=%S, new-referent=%S" new-refere new-referent) ;; debugging
- (when (> (length new-refere) 0)
- (if (> (length new-referent) 0)
- (setq args (mapcar (lambda (ref) (cons :var ref))
- (org-babel-ref-split-args new-referent))))
- ;; (message "args=%S" args) ;; debugging
- (setq ref new-refere)))
- (when (string-match "^\\(.+\\):\\(.+\\)$" ref)
- (setq split-file (match-string 1 ref))
- (setq split-ref (match-string 2 ref))
- (find-file split-file) (setq ref split-ref))
- (goto-char (point-min))
- (if (let ((result_regexp (concat "^#\\+\\(TBLNAME\\|RESNAME\\|RESULTS\\):[ \t]*"
- (regexp-quote ref) "[ \t]*$"))
- (regexp (concat org-babel-source-name-regexp
- (regexp-quote ref) "\\(\(.*\)\\)?" "[ \t]*$")))
- ;; goto ref in the current buffer
- (or (and (not args)
- (or (re-search-forward result_regexp nil t)
- (re-search-backward result_regexp nil t)))
- (re-search-forward regexp nil t)
- (re-search-backward regexp nil t)
- ;; check the Library of Babel
- (setq lob-info (cdr (assoc (intern ref) org-babel-library-of-babel)))))
- (unless lob-info (goto-char (match-beginning 0)))
- ;; ;; TODO: allow searching for names in other buffers
- ;; (setq id-loc (org-id-find ref 'marker)
- ;; buffer (marker-buffer id-loc)
- ;; loc (marker-position id-loc))
- ;; (move-marker id-loc nil)
- (progn (message (format "reference '%s' not found in this buffer" ref))
- (error (format "reference '%s' not found in this buffer" ref))))
- (if lob-info
- (setq type 'lob)
- (while (not (setq type (org-babel-ref-at-ref-p)))
- (forward-line 1)
- (beginning-of-line)
- (if (or (= (point) (point-min)) (= (point) (point-max)))
- (error "reference not found"))))
- (setq params (org-babel-merge-params params args '((:results . "silent"))))
- (setq result
- (case type
- ('results-line (org-babel-read-result))
- ('table (org-babel-read-table))
- ('file (org-babel-read-file))
- ('source-block (org-babel-execute-src-block nil nil params))
- ('lob (org-babel-execute-src-block nil lob-info params))))
- (if (symbolp result)
- (format "%S" result)
- (if (and index (listp result))
- (org-babel-ref-index-list index result)
- result)))))
- (defun org-babel-ref-index-list (index lis)
- "Return the subset of LIS indexed by INDEX. If INDEX is
- separated by ,s then each PORTION is assumed to index into the
- next deepest nesting or dimension. A valid PORTION can consist
- of either an integer index, or two integers separated by a : in
- which case the entire range is returned."
- (if (string-match "^,?\\([^,]+\\)" index)
- (let ((length (length lis))
- (portion (match-string 1 index))
- (remainder (substring index (match-end 0))))
- (flet ((wrap (num) (if (< num 0) (+ length num) num))
- (open (lis) (if (and (listp lis) (= (length lis) 1)) (car lis) lis)))
- (open
- (mapcar
- (lambda (sub-lis) (org-babel-ref-index-list remainder sub-lis))
- (if (string-match "\\(\\([-[:digit:]]+\\):\\([-[:digit:]]+\\)\\|\*\\)"
- portion)
- (mapcar (lambda (n) (nth n lis))
- (apply 'number-sequence
- (if (match-string 2 portion)
- (list
- (wrap (string-to-number (match-string 2 portion)))
- (wrap (string-to-number (match-string 3 portion))))
- (list (wrap 0) (wrap -1)))))
- (list (nth (wrap (string-to-number portion)) lis)))))))
- lis))
- (defun org-babel-ref-split-args (arg-string)
- "Split ARG-STRING into top-level arguments of balanced parenthesis."
- (let ((index 0) (depth 0) (buffer "") holder return)
- ;; crawl along string, splitting at any ","s which are on the top level
- (while (< index (length arg-string))
- (setq holder (substring arg-string index (+ 1 index)))
- (setq buffer (concat buffer holder))
- (setq index (+ 1 index))
- (cond
- ((string= holder ",")
- (when (= depth 0)
- (setq return (reverse (cons (substring buffer 0 -1) return)))
- (setq buffer "")))
- ((or (string= holder "(") (string= holder "[")) (setq depth (+ depth 1)))
- ((or (string= holder ")") (string= holder "]")) (setq depth (- depth 1)))))
- (mapcar #'org-babel-trim (reverse (cons buffer return)))))
- (defun org-babel-ref-at-ref-p ()
- "Return the type of reference located at point or nil if none
- of the supported reference types are found. Supported reference
- types are tables and source blocks."
- (cond ((org-at-table-p) 'table)
- ((looking-at "^#\\+BEGIN_SRC") 'source-block)
- ((looking-at org-bracket-link-regexp) 'file)
- ((looking-at org-babel-result-regexp) 'results-line)))
- (provide 'org-babel-ref)
- ;;; org-babel-ref.el ends here
|