Re: [Orgmode] Re: [Babel] Need for an extra literal block construct

[Eric Schulte]

"Eric Schulte" <address@hidden> writes:

> This would be useful for custom export of the proposed future babel
> results block (which I promise I'll implement soon).

An experimental patch implementing wrapping of results using a new
"wrap" :results header argument is attached.  Here is an example of its
usage.

** introducing =wrap= header argument
#+begin_src emacs-lisp :results wrap
  (mapcar (lambda (el) (list el (+ 1 (* el el)))) (number-sequence 0 10))
#+end_src

#+results:
#+BEGIN_RESULT
|  0 |   1 |
|  1 |   2 |
|  2 |   5 |
|  3 |  10 |
|  4 |  17 |
|  5 |  26 |
|  6 |  37 |
|  7 |  50 |
|  8 |  65 |
|  9 |  82 |
| 10 | 101 |
#+END_RESULT

now indented
- first
- second
  #+begin_src emacs-lisp :results wrap
    "something else"
  #+end_src

  #+results:
  #+BEGIN_RESULT
  : something else
  #+END_RESULT


I haven't applied it directly to the repository because I fear it could
have negative effects on the wrapping of results in HTML and LaTeX
blocks, so if any brave souls could try this out over the next day or
two and let me know how it works I'd then feel much more comfortable
about dropping it into the core.

Best -- Eric

>From e2589d43280164dbcb2e1d3b18ef6bf23ac99b6b Mon Sep 17 00:00:00 2001
From: Eric Schulte <address@hidden>
Date: Fri, 19 Nov 2010 16:04:59 -0700
Subject: [PATCH] "wrap" :results header argument wraps code block results

* lisp/ob.el (org-babel-insert-result): Responds to new "wrap" header
  argument.
  (org-babel-merge-params): Includes new "wrap" header argument in
  one of the results header argument exclusive groups.
---
 lisp/ob.el |   72 +++++++++++++++++++++++++++++------------------------------
 1 files changed, 35 insertions(+), 37 deletions(-)

diff --git a/lisp/ob.el b/lisp/ob.el
index 3689619..9feb0a6 100644
--- a/lisp/ob.el
+++ b/lisp/ob.el
@@ -1433,11 +1433,11 @@ code ---- the results are extracted in the syntax of 
the source
            (delete-region (point) (org-babel-result-end)))
           ((member "append" result-params)
            (goto-char (org-babel-result-end)) (setq beg (point)))
-          ((member "prepend" result-params) ;; already there
-           )))
+          ((member "prepend" result-params)))) ; already there
        (setq results-switches
              (if results-switches (concat " " results-switches) ""))
-       (cond
+       ;; insert results based on type
+       (cond                        
         ;; do nothing for an empty result
         ((= (length result) 0))
         ;; insert a list if preferred
@@ -1449,6 +1449,7 @@ code ---- the results are extracted in the syntax of the 
source
                                 '(:splicep nil :istart "- " :iend "\n")))))
         ;; assume the result is a table if it's not a string
         ((not (stringp result))
+         (goto-char beg)
          (insert (concat (orgtbl-to-orgtbl
                           (if (or (eq 'hline (car result))
                                   (and (listp (car result))
@@ -1458,24 +1459,30 @@ code ---- the results are extracted in the syntax of 
the source
          (goto-char beg) (when (org-at-table-p) (org-table-align)))
         ((member "file" result-params)
          (insert result))
-        ((member "html" result-params)
-         (insert (format "#+BEGIN_HTML%s\n%s#+END_HTML\n"
-                         results-switches result)))
-        ((member "latex" result-params)
-         (insert (format "#+BEGIN_LaTeX%s\n%s#+END_LaTeX\n"
-                         results-switches result)))
-        ((member "code" result-params)
-         (insert (format "#+BEGIN_SRC %s%s\n%s#+END_SRC\n"
-                         (or lang "none") results-switches result)))
-        ((member "org" result-params)
-         (insert (format "#+BEGIN_SRC org\n%s#+END_SRC\n" result)))
-        ((member "raw" result-params)
-         (save-excursion (insert result)) (if (org-at-table-p) (org-cycle)))
-        (t
-         (org-babel-examplize-region
-          (point) (progn (insert result) (point)) results-switches)))
-       ;; possibly indent the results to match the #+results line
+        (t (goto-char beg)
+           (org-babel-examplize-region
+            (point) (progn (insert result) (point)) results-switches)))
        (setq end (if (listp result) (org-table-end) (point)))
+       ;; possibly wrap result
+       (flet ((wrap (start finish)
+                    (goto-char beg) (insert start)
+                    (goto-char (+ (if (listp result) 0 (length start)) end))
+                    (insert finish) (setq end (point))))
+         (cond
+          ((member "html" result-params)
+           (wrap "#+BEGIN_HTML\n" "#+END_HTML"))
+          ((member "latex" result-params)
+           (wrap "#+BEGIN_LaTe\n" "#+END_LaTeX"))
+          ((member "code" result-params)
+           (wrap (format "#+BEGIN_SRC %s%s\n" (or lang "none") 
results-switches)
+                 "#+END_SRC"))
+          ((member "org" result-params)
+           (wrap "#+BEGIN_ORG\n" "#+END_ORG"))
+          ((member "raw" result-params)
+           (goto-char beg) (if (org-at-table-p) (org-cycle)))
+          ((member "wrap" result-params)
+           (wrap "#+BEGIN_RESULT\n" "#+END_RESULT"))))
+       ;; possibly indent the results to match the #+results line
        (when (and indent (> indent 0)
                   ;; in this case `table-align' does the work for us
                   (not (and (listp result)
@@ -1503,22 +1510,13 @@ code ---- the results are extracted in the syntax of 
the source
      ((org-at-table-p) (progn (goto-char (org-table-end)) (point)))
      ((org-in-item-p) (- (org-list-bottom-point) 1))
      (t
-      (let ((case-fold-search t))
-        (cond
-         ((looking-at "[ \t]*#\\+begin_latex")
-          (re-search-forward "[ \t]*#\\+end_latex" nil t)
-          (forward-line 1))
-         ((looking-at "[ \t]*#\\+begin_html")
-          (re-search-forward "[ \t]*#\\+end_html" nil t)
-          (forward-line 1))
-         ((looking-at "[ \t]*#\\+begin_example")
-          (re-search-forward "[ \t]*#\\+end_example" nil t)
-          (forward-line 1))
-         ((looking-at "[ \t]*#\\+begin_src")
-          (re-search-forward "[ \t]*#\\+end_src" nil t)
-          (forward-line 1))
-         (t (progn (while (looking-at "[ \t]*\\(: \\|\\[\\[\\)")
-                     (forward-line 1))))))
+      (let ((case-fold-search t)
+           (blocks-re (regexp-opt
+                       (list "latex" "html" "example" "src" "result"))))
+       (if (looking-at (concat "[ \t]*#\\+begin_" blocks-re))
+           (re-search-forward (concat "[ \t]*#\\+end_" blocks-re) nil t)
+         (while (looking-at "[ \t]*\\(: \\|\\[\\[\\)")
+           (forward-line 1))))
       (point)))))
 
 (defun org-babel-result-to-file (result)
@@ -1570,7 +1568,7 @@ This takes into account some special considerations for 
certain
 parameters when merging lists."
   (let ((results-exclusive-groups
         '(("file" "list" "vector" "table" "scalar" "raw" "org"
-            "html" "latex" "code" "pp")
+            "html" "latex" "code" "pp" "wrap")
           ("replace" "silent" "append" "prepend")
           ("output" "value")))
        (exports-exclusive-groups
-- 
1.7.0.4