From badc80465860ad63251ae68170cc09daa676b490 Mon Sep 17 00:00:00 2001 From: chasberry Date: Thu, 13 Nov 2014 20:45:01 -0800 Subject: [PATCH 1/3] lisp/ob-core.el: Inline source block results are replaceable * lisp/ob-core.el (org-babel-insert-result): Delete any `results' macro following current inline src block; insert current value in 'results' macro possibly wrapping RESULT in an export snippet or inline source block first. Protect commas and backslash commas in the RESULT with backslashes if the macro form is used. * lisp/ob-core.el (org-babel-remove-inline-result): Add function to delete "{{{results(.*)}}}" macro call of current inline src block. Inline source block results can be removed by re-executing the source block if they are wrapped in a `{{{results(...)}}}' macro. The schema for the RESULT-PARAMS is: | Param | Example output | |---------+-----------------------------------+ | default | {{{results(42)}}} | | file | {{{results(file:something.pdf)}}} | | list | \n: - 42\n\n | | raw | 42 | | drawer | {{{results(42)}}} | | org | {{{results(src_org{...})}}} | | html | {{{results(@@html:...@@)}}} | | latex | {{{results(@@latex:...@@)}}} | | code | {{{results(src_xxx{...})}}} | | table | \n| 42 |\n\n | |---------+-----------------------------------+ where the default is `src_emacs{42}' and subsequent rows give the `:results' arg. The `:wrap something' header arg gives an effect similar to `:results html' or `:results latex'. On export, the macro is stripped away before parsing leaving only its contents. Combining RESULT-PARAMS that use the `results' macro can cause havoc. Standard source blocks or the `raw' arg should generally be used for complicated constructions of RESULT-PARAMS, lists, tables, and/or multi-line RESULTs. --- lisp/ob-core.el | 114 +++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 84 insertions(+), 30 deletions(-) diff --git a/lisp/ob-core.el b/lisp/ob-core.el index 93fcb2a..80542ec 100644 --- a/lisp/ob-core.el +++ b/lisp/ob-core.el @@ -2073,13 +2073,18 @@ If the path of the link is a file path it is expanded using (defun org-babel-insert-result (result &optional result-params info hash indent lang) "Insert RESULT into the current buffer. -By default RESULT is inserted after the end of the -current source block. With optional argument RESULT-PARAMS -controls insertion of results in the org-mode file. +By default RESULT is inserted after the end of the current source +block. The RESULT of an inline source block usually will be +wrapped inside a `results' macro and placed on the same line as +the inline source block. The macro is stripped upon +export. Multiline and non-scalar RESULTS from inline source +blocks are fragile and should be avoided. With optional argument +RESULT-PARAMS controls insertion of results in the org-mode file. RESULT-PARAMS can take the following values: replace - (default option) insert results after the source block - replacing any previously inserted results + or inline source block replacing any previously + inserted results silent -- no results are inserted into the Org-mode buffer but the results are echoed to the minibuffer and are @@ -2096,8 +2101,9 @@ raw ----- results are added directly to the Org-mode file. This formatted text. drawer -- results are added directly to the Org-mode file as with - \"raw\", but are wrapped in a RESULTS drawer, allowing - them to later be replaced or removed automatically. + \"raw\", but are wrapped in a RESULTS drawer or results + macro, allowing them to later be replaced or removed + automatically. org ----- results are added inside of a \"src_org{}\" or \"#+BEGIN_SRC org\" block depending on whether the current source block is @@ -2105,13 +2111,15 @@ org ----- results are added inside of a \"src_org{}\" or \"#+BEGIN_SRC but Org syntax here will be discarded when exporting the file. -html ---- results are added inside of a #+BEGIN_HTML block. This - is a good option if you code block will output html - formatted text. +html ---- results are added inside of a #+BEGIN_HTML block or + html export snippet depending on whether the current + source block is inline or not. This is a good option + if you code block will output html formatted text. -latex --- results are added inside of a #+BEGIN_LATEX block. - This is a good option if you code block will output - latex formatted text. +latex --- results are added inside of a #+BEGIN_LATEX block or + latex export snippet depending on whether the current + source block is inline or not. This is a good option + if you code block will output latex formatted text. code ---- the results are extracted in the syntax of the source code of the language being evaluated and are added @@ -2138,9 +2146,12 @@ code ---- the results are extracted in the syntax of the source (when (or (org-babel-get-inline-src-block-matches) (org-babel-get-lob-one-liner-matches)) (goto-char (match-end 0)) - (insert (if (listp result) "\n" " ")) + (insert (if (or (listp result) + (member "list" result-params)) + "\n" " ")) (point)))) - (existing-result (unless inlinep + (existing-result (if inlinep + (org-babel-remove-inline-result) (org-babel-where-is-src-block-result t info hash indent))) (results-switches @@ -2179,7 +2190,12 @@ code ---- the results are extracted in the syntax of the source ((member "prepend" result-params)))) ; already there (setq results-switches (if results-switches (concat " " results-switches) "")) - (let ((wrap (lambda (start finish &optional no-escape no-newlines) + (let ((wrap (lambda (start finish &optional no-escape no-newlines + inline-start inline-finish) + (when inlinep + (setq start inline-start) + (setq finish inline-finish) + (setq no-newlines t)) (goto-char end) (insert (concat finish (unless no-newlines "\n"))) (goto-char beg) @@ -2196,6 +2212,7 @@ code ---- the results are extracted in the syntax of the source ((null result)) ;; insert a list if preferred ((member "list" result-params) + (goto-char beg) (insert (org-babel-trim (org-list-to-generic @@ -2220,6 +2237,19 @@ code ---- the results are extracted in the syntax of the source ((member "file" result-params) (when inlinep (goto-char inlinep)) (insert result)) + ;; escape commas, e.g. {{{results(a\,b)}}} + ((and inlinep + (not (member "raw" result-params))) + (goto-char beg) + (insert + ;; Escape commas and preceding backslash per + ;; (info "(org) Macro replacement"). + (replace-regexp-in-string + "\\(\\\\*\\)\\(,\\)" + (lambda (str) + (let ((len (length (match-string 1 str)))) + (concat (make-string (* 2 (/ len 2)) ?\\) "\\,"))) + result nil t))) (t (goto-char beg) (insert result))) (when (funcall proper-list-p result) (goto-char (org-table-end))) (setq end (point-marker)) @@ -2228,34 +2258,41 @@ code ---- the results are extracted in the syntax of the source ((assoc :wrap (nth 2 info)) (let ((name (or (cdr (assoc :wrap (nth 2 info))) "RESULTS"))) (funcall wrap (concat "#+BEGIN_" name) - (concat "#+END_" (car (org-split-string name)))))) + (concat "#+END_" (car (org-split-string name))) + nil nil (concat "{{{results(@@" name ":") "@@)}}}"))) ((member "html" result-params) - (funcall wrap "#+BEGIN_HTML" "#+END_HTML")) - ((member "latex" result-params) - (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX")) + (funcall wrap "#+BEGIN_HTML" "#+END_HTML" nil nil + "{{{results(@@html:" "@@)}}}")) + ((member "latex" result-params) + (funcall wrap "#+BEGIN_LaTeX" "#+END_LaTeX" nil nil + "{{{results(@@latex:" "@@)}}}")) ((member "org" result-params) (goto-char beg) (if (org-at-table-p) (org-cycle)) - (if inlinep - (funcall wrap "src_org{" "}" nil t) - (funcall wrap "#+BEGIN_SRC org" "#+END_SRC"))) + (funcall wrap "#+BEGIN_SRC org" "#+END_SRC" nil nil + "{{{results(src_org{" "})}}}")) ((member "code" result-params) (let ((lang (or lang "none"))) - (if inlinep - (funcall wrap (format "src_%s[%s]{" lang results-switches) - "}" nil t) - (funcall wrap (format "#+BEGIN_SRC %s%s" lang results-switches) - "#+END_SRC")))) + (funcall wrap (format "#+BEGIN_SRC %s%s" lang results-switches) + "#+END_SRC" nil nil + (format "{{{results(src_%s[%s]{" lang results-switches) + "})}}}"))) ((member "raw" result-params) (goto-char beg) (if (org-at-table-p) (org-cycle))) ((or (member "drawer" result-params) ;; Stay backward compatible with <7.9.2 (member "wrap" result-params)) (goto-char beg) (if (org-at-table-p) (org-cycle)) - (funcall wrap ":RESULTS:" ":END:" 'no-escape)) + (funcall wrap ":RESULTS:" ":END:" 'no-escape nil + "{{{results(" ")}}}")) + ((and inlinep (member "file" result-params)) + (funcall wrap nil nil nil nil "{{{results(" ")}}}")) ((and (not (funcall proper-list-p result)) (not (member "file" result-params))) - (org-babel-examplify-region beg end results-switches) - (setq end (point))))) + (let ((org-babel-inline-result-wrap + ;; Hard code {{{results(...)}}} on top of customization. + (format "{{{results(%s)}}}" org-babel-inline-result-wrap))) + (org-babel-examplify-region beg end results-switches) + (setq end (point)))))) ;; possibly indent the results to match the #+results line (when (and (not inlinep) (numberp indent) indent (> indent 0) ;; in this case `table-align' does the work for us @@ -2283,6 +2320,23 @@ code ---- the results are extracted in the syntax of the source (if keep-keyword (1+ (match-end 0)) (1- (match-beginning 0))) (progn (forward-line 1) (org-babel-result-end)))))))) +(defun org-babel-remove-inline-result () + "Remove the result of the current inline-src-block if it is + wrapped in a `results' macro and trim extraneous leading whitespace." + (let ((el (org-element-context)) post-blank) + (when (eq (org-element-type el) 'inline-src-block) + (save-excursion + (setq post-blank (org-element-property :post-blank el)) + (goto-char (org-element-property :end el)) + (setq el (org-element-context)) + (when (and (eq (org-element-type el) 'macro) + (equal (org-element-property :key el) "results")) + (delete-region ; And (only) extra leading whitespace. + (- (org-element-property :begin el) + (- post-blank 1)) + (- (org-element-property :end el) + (org-element-property :post-blank el)))))))) + (defun org-babel-remove-result-one-or-many (x) "Remove the result of the current source block. If called with a prefix argument, remove all result blocks -- 1.9.3 (Apple Git-50)