[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [O] exporting documents w/ babel results w/o evaluating babel blocks

From: Charles C. Berry
Subject: Re: [O] exporting documents w/ babel results w/o evaluating babel blocks
Date: Sun, 22 May 2016 14:52:45 -0700
User-agent: Alpine 2.20 (OSX 67 2015-01-07)

John and Nick,

Comments in line below.

TL;DR: Org babel headers give excellent control over what gets run,
when it gets run, and how. Users should use them. Don't reset


On Sun, 22 May 2016, John Hendy wrote:

On Fri, May 20, 2016 at 4:20 PM, Charles C. Berry <address@hidden> wrote:
On Fri, 20 May 2016, Nick Dokos wrote:

Ken Mankoff <address@hidden> writes:

[deleted discussion of  `org-export-babel-evaluate' settings]

With ":exports results" and o-e-b-e set to nil, I get no evaluation on
export, but I get both code and results in the output.

There may have been a misunderstanding, but when I mentioned this in
the bug report, I was told this is a "feature".


Not sure what exactly Chuck meant is a feature, but IIUC, the fact
that I get both code and results even if I specify ":exports results"
looks like a bug to me.

I meant this, as of commit ec615b1..., `org-export-babel-evaluate' set to
`nil' keeps the exporter from running this line


during exports. So, 'no Babel code is run' in the sense that the above
line does not execute.

src-blocks and inline-src-blocks are neither run nor removed, and no
#+results:<etc> or {{{results()}}} are added, removed, or
modified. Babel handles all that. The exporter merely formats those
things once Babel is done.

So the bug, if any, is in the docstring in failing to mention that
everything that babel does is switched off.

I don't entirely follow. Is there an intermediate step between a .org
src block, babel, and the exporter? If so, the behavior I see could
make sense. If not, then it doesn't.

As in, why is babel "execution" (as in o-e-b-e to non-nil) required to
*not* export this code into the resultant pdf?

#+begin_src R :exports results :results output
 dat <- 1:10

With o-e-b-e set to nil, I get the code in the exported document,
hence my asking. If I turn o-e-b-e on, I don't (but get the results).
So perhaps the real missing bit from the documentation is something
like "all babel functionality is turned off, and babel is responsible
for executing code and generating/updating any results, as well as
controlling src block export controls (results vs. code vs. both). In
other words, without babel, src blocks in .org files are treated like
example blocks during export."

Is that accurate?

Yes. That is the point. Babel does it all.

(Caveat: 'like example blocks' is not precisely true, since the
exporter calls a src-block transcoder for the formatting.)

I think one of the main points of confusion in this thread still has
to do with why o-e-b-e switches what gets exported. If no code/results
are run/added/removed/modified as you mention, it doesn't speak to why
code export is always done for o-e-b-e = nil, but not otherwise. This
suggests babel is doing more than "executing code;" it's somehow
influencing what makes it into the export document. At least for me,
that was an unexpected interpretation of "everything babel does is
switched off."

Babel is a fairly complicated beast.

If you want to grok what it is doing during export, you could instrument `org-export-as' (do `(info "(elisp) Edebug")' if you need to know about this), export something with babel code in it, and step thru to just before the line `(org-export-execute-babel-code)'. At that point have a look at the temp buffer the exporter is working in. (IIRC, it will have <2> suffixed to the name of the buffer from which you started the export.) Then do one more step to run the babel code and look again - be sure it is *still* the buffer named with the *<2> format that you are inspecting now. You will see what it is that Babel has done.

In particular, a src block with no results initially, but with
`:exports results' as a header will be gone, but results will now be

A src block that is has `#+begin-src emacs-lisp :exports code' will
survive, but the header arg will be gone. So, transcoders in the
exporter will not see the header arg.

In fact, I just had an idea... I have o-e-b-e set to always, but just
turned org-confirm-babel-evaluate to on (I typically have it off). If
export the above and type "no" to make sure the code block is not
executed I do *not* get the code in the document. I think this
confirms that babel's responsibilities include *what* plain text in
.org the exporter formats into the output format.

My suggestion would be to create a different variable to handle
formatting vs. execution unless things were designed this way? It
seems from all the comments that the majority of users expect the
time-heavy *code* not to be run at each export but still prefer the
blocks to behave as they intended.

This is what `:eval never-export' was created for.

Theoretically, with all of my
results generated (e.g. into .pdf, .png, etc. plots; ascii tables,
whatever) shouldn't I be able to have o-e-b-e set to whatever and get
the same document? My document no longer depends on any of the code...
so I don't need it run, but the exported document will behave like
:exports both instead of :exports results just from turning babel off.

It sounds simple, but babel has a lot woven into it and getting the behavior you suggest by setting variables like o-e-b-e in emacs without breaking things is tricky. Consider what happens when you have something like:

#+BEGIN_SRC emacs-lisp :var x=abc() :noweb yes :exports both

With o-e-b-e nil, what should happen? If nothing runs, x does not get set because abc() does not run, nor does the noweb code substitution take place because that requires the `format-some-code' src-block to run. If only some things `ought to' be run, how does the program decide which ones?

Currently, the user can fine tune what is run and what is not during
export using Babel headers. Let babel run and the headers will sort
out the rest.

Frankly, I do not see why users would want to mess with o-e-b-e except
in unusual cases - like debugging a complicated document, where having
Babel changing things around could just make things harder.

If there is a use case for a capability that is not well supported by
existing headers it would be good to have an example.


reply via email to

[Prev in Thread] Current Thread [Next in Thread]