Is it possible to #+include: src blocks and tangle them too?

Is it possible to #+include: src blocks and tangle them too?

[Ramachandran Lakshmanan]

[-- Attachment #1: Type: text/plain, Size: 676 bytes --]

I have been wanting to include a number of small Common Lisp snippets in
individual files which I then include into a "master" .org file using:

#+include: "snippet.org" src lisp

Within snippet.org I have a src block such as:

#+NAME: hello_test
#+BEGIN_SRC lisp :tangle yes
(defun hello () :hello)
#+END_SRC

Ideally I would like to have some specific comments that will be part of
the Literate Program I would develop from these individual files.

However, it seems as though tangling doesn't work.  Export does.

I read somewhere that this is not possible in orgmode.  Is this true?  And
if not, can you point me to the right documentation?

Many thanks.

Rama Lakshmanan

[-- Attachment #2: Type: text/html, Size: 1040 bytes --]

Re: Is it possible to #+include: src blocks and tangle them too?

[Nicolas Goaziou]

Hello,

Ramachandran Lakshmanan <rama@tzrl.org> writes:

> I have been wanting to include a number of small Common Lisp snippets in
> individual files which I then include into a "master" .org file using:
>
> #+include: "snippet.org" src lisp
>
> Within snippet.org I have a src block such as:
>

[...]

> I read somewhere that this is not possible in orgmode.  Is this true?  And
> if not, can you point me to the right documentation?

#+include is a keyword specific to export. I doubt it would work with
tangling out of the box.

However, you may try calling `org-export-expand-include-keyword' from
`org-babel-pre-tangle-hook'. Untested.

Regards,
-- 
Nicolas Goaziou

Re: Is it possible to #+include: src blocks and tangle them too?

[Dr. Arne Babenhauserheide]

[-- Attachment #1: Type: text/plain, Size: 1283 bytes --]


Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

> Hello,
>
> Ramachandran Lakshmanan <rama@tzrl.org> writes:
>
>> I have been wanting to include a number of small Common Lisp snippets in
>> individual files which I then include into a "master" .org file using:
>>
>> #+include: "snippet.org" src lisp
>>
>> Within snippet.org I have a src block such as:
>>
>
> [...]
>
>> I read somewhere that this is not possible in orgmode.  Is this true?  And
>> if not, can you point me to the right documentation?
>
> #+include is a keyword specific to export. I doubt it would work with
> tangling out of the box.

I tried it but didn’t get it to work. As solution I turned to autotools:

Variable definitions:
https://hg.sr.ht/~arnebab/ews/browse/Hauptdokument/ews30/configure.ac?ref=9b6d7459f2b1#L40
AC_SUBST_FILE(tabelle_kernantriebe)
tabelle_kernantriebe=$srcdir/tabelle-kernantriebe.org

Replacement definition:
https://hg.sr.ht/~arnebab/ews/browse/Hauptdokument/ews30/configure.ac?ref=9b6d7459f2b1#L69
AC_CONFIG_FILES([chargen.org])

Usage:
https://hg.sr.ht/~arnebab/ews/browse/Hauptdokument/ews30/chargen.org.in?ref=9b6d7459f2b1#L552
@tabelle_kernantriebe@

Best wishes,
Arne
-- 
Unpolitisch sein
heißt politisch sein
ohne es zu merken

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 1125 bytes --]

Re: Is it possible to #+include: src blocks and tangle them too?

[Timothy]

Nicolas Goaziou <mail@nicolasgoaziou.fr> writes:

> #+include is a keyword specific to export. I doubt it would work with
> tangling out of the box.
>
> However, you may try calling `org-export-expand-include-keyword' from
> `org-babel-pre-tangle-hook'. Untested.

Doom has been doing this for a while with config.org tangling:
https://github.com/hlissner/doom-emacs/blob/ce65645fb87ed1b24fb1a46a33f77cf1dcc1c0d5/bin/org-tangle#L155

--
Timothy

Re: Is it possible to #+include: src blocks and tangle them too?

[Kevin M. Stout]

On 2021-04-12 23:38, Nicolas Goaziou wrote:

> However, you may try calling `org-export-expand-include-keyword' from
> `org-babel-pre-tangle-hook'. Untested.

I've done this in the past and can verify that it works well.  That said, it by
definition creates cross-talk between org files, with all the potential for name
collisions and the like that that implies.  One could avoid such problems by
adding some kind of prefix to the block names in the included file (maybe
"common/" or "xyzzy-").  (Some kind of automatic prefixing on inclusion might be
cool.)

--Kevin M. Stout

Re: Is it possible to #+include: src blocks and tangle them too?

[Greg Minshall]

Rama,

another possible solution, though it may not be possible for your setup,
is to "invert" things: centralize all your snippets in snippet.org, with
each *snippet* set to tangle to its individual lisp file.

cheers, Greg

Re: Is it possible to #+include: src blocks and tangle them too?

[Rama]

[-- Attachment #1: Type: text/plain, Size: 3035 bytes --]

Thank you, Greg, this is certainly a logical suggestion, but I didn’t explain why I would have these blocks in individual files - I will explain very quickly here.

Basically I am developing my Lisp code using the ASDF package manager and so I have a few different files in a source tree. I haven’t been able to fully work with Donald Knuth’s suggestion of writing a Literate Program directly in a tool like orgmode/noweb since it is a nuisance to keep having to type C-c ' to go into the editing mode of the language concerned.

I also tend to use a mindmapping tool (MindNode on my Mac in my case) since with some specific genetic mental issues I do better with a visual outline than the standard ones even the flexible offering in orgmode itself. I’m fine once I’ve done the brainstorming, and I then will export to OPML and use Pandoc to get an orgmode file.

But what I wanted to do was to insert Javadoc style comments into my Lisp in my original code and I would label each entry with the name of the source code block which also gets named <name>.org in a flat folder.

For example

;;;——
;;; metrics_graph
;;; ——
;;; Textual essay paragraphs
;;; ——
(defun nothing () nil)
;;;——

The above is in metrics_graph.org (http://metrics_graph.org)

All these generated files are styled as a very simple markdown file so that I can read this into MindNode and have a bunch of nodes named with the names of the org snippets as I have called them (confusingly as "snippet" has a different connotation most often).

With these mechanics I can write my Lisp code as I have done for years but I can also have it easily translated into a set of Nodes in MindNode that I can move around graphically with a mouse and create my Literate Program.

Ultimately I have just decided that I will develop my code as normal and then finally just copy and paste it into orgmode especially since now we can select a region and and create a source block around it.

So taking a Lisp file and formatting it for orgmode is not a huge burden - then I will be able to tangle it and I will just then continue to work from the org file if I need to edit and debug the code later on. It just means I will take the code to near completion before trying to work with a Literate Program but I do hope to start using Babel for documenting my work even though I am no longer working in a research setting per se.

Thanks to all for your suggestions - Doom seems a reasonable option - but I will try them all as best I can - I am on my second all nighter though so need some sleep first!

Cheers.

Rama

--
Sent from Canary (https://canarymail.io)

> On Wednesday, Apr 14, 2021 at 4:23 am, Greg Minshall <minshall@umich.edu (mailto:minshall@umich.edu)> wrote:
> Rama,
>
> another possible solution, though it may not be possible for your setup,
> is to "invert" things: centralize all your snippets in snippet.org, with
> each *snippet* set to tangle to its individual lisp file.
>
> cheers, Greg

[-- Attachment #2: Type: text/html, Size: 4166 bytes --]

Re: Is it possible to #+include: src blocks and tangle them too?

[Dr. Arne Babenhauserheide]

[-- Attachment #1: Type: text/plain, Size: 778 bytes --]


Rama <rama@tzrl.org> writes:
> Ultimately I have just decided that I will develop my code as normal and then finally just copy and paste it into orgmode especially since now we can select a region and and create a source block around it.

Do you know M-x insert-file? That could simplify your workfloww a lot.

Even better could be M-x org-detangle with the :comments link header of
the source-block. When executed in a tangled file, it brings its changes
back into the org-file. I’ve been using it for a site of mine,¹ and it
finally brought specialized-mode development and org-mode together for
me.


¹: https://hg.sr.ht/~arnebab/draketo/browse/anderes/mathe-ass.org?rev=3bc0f27d5471#L284

-- 
Unpolitisch sein
heißt politisch sein
ohne es zu merken

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 1125 bytes --]

Re: Is it possible to #+include: src blocks and tangle them too?

[Greg Minshall]

Rama,

thanks for your explanation.

Arne Babenhauserheide suggested [M-x org-babel-detangle]; i've not used
it myself, but it seems a possible direction.

cheers, Greg

Re: Is it possible to #+include: src blocks and tangle them too?

[Greg Minshall]

Rama,

one other comment/suggestion.

> I haven’t been able to fully work with Donald Knuth’s suggestion of
> writing a Literate Program directly in a tool like orgmode/noweb since
> it is a nuisance to keep having to type C-c ' to go into the editing
> mode of the language concerned.

while i have not much experience with it, you might look at the emacs
packages polymode, poly-org, and poly-whatever-other-languages-you-use.
it seems as if they might give you [C-c ']-like behavior when editing
source blocks in line in an org mode buffer.

(others who use polymode: does this make sense?)

cheers, Greg

Re: Is it possible to #+include: src blocks and tangle them too?

[Berry, Charles via General discussions about Org-mode.]

Hi Greg,

> On Apr 16, 2021, at 8:27 AM, Greg Minshall <minshall@umich.edu> wrote:
> 
> Rama,
> 
> one other comment/suggestion.
> 
>> I haven’t been able to fully work with Donald Knuth’s suggestion of
>> writing a Literate Program directly in a tool like orgmode/noweb since
>> it is a nuisance to keep having to type C-c ' to go into the editing
>> mode of the language concerned.
> 
> while i have not much experience with it, you might look at the emacs
> packages polymode, poly-org, and poly-whatever-other-languages-you-use.
> it seems as if they might give you [C-c ']-like behavior when editing
> source blocks in line in an org mode buffer.
> 
> (others who use polymode: does this make sense?)


I have tried it a few times, but not had satisfactory results. 

I use mostly R src blocks, so I want to have ESS like functionality. And I really like to be able to execute src blocks with `org-babel-execute-src-block'. 

Unfortunately, it seems like polymode gets into conflicts with org mode from time to time. My memory is a bit dim on exactly the issues, but I think there were freezes. Maybe turning off all the stops and whistles in org mode (like fontification) would solve this, but I never gave it a go. 

Having said that, I will say it is easy enough to install and try out. And perhaps your mileage will vary.

Best,
Chuck