indentation of expanded code blocks

[shakfu]

I just noticed that the worgle does't indent the expanded code block as expected (my sole experience in literate programming is via leo-editor).

For example the following test.org

#+TITLE:Worgle Indentation Test

#+NAME: top
#+BEGIN_SRC c :tangle hello.c
#include <stdio.h>

int main(int argc, char *argv[])
{
    <<say_the_worgle_greeting>>
    return 0;
}
#+END_SRC

#+NAME: say_the_worgle_greeting
#+BEGIN_SRC c
printf("Hello Worleg Borgle!\n");
#+END_SRC

To tangle, run:

#+NAME: generate_and_run
#+BEGIN_SRC sh
./lit README.org
gcc hello.c -o hello
./hello
#+END_SRC

This gets tangled to hello.c as follows

#include <stdio.h>

int main(int argc, char *argv[])
{
printf("Hello Worleg Borgle!\n");
    return 0;
}

instead of what I expected:

#include <stdio.h>

int main(int argc, char *argv[])
{
    printf("Hello Worleg Borgle!\n");
    return 0;
}

Of course this is not a big deal for bracketed languages, but with something like python it becomes an issue.
Is this straightforward to fix?

[PaulBatchelor]

Is this straightforward to fix?

I'll have to look into it, but it might take a some work.

Named codeblocks typically exist on their own line, without anything coming before it or after it. It looks like I added an exception to this at some point, which was preceding whitespace on the line. What seems to happen is that that whitespace is discarded entirely. I also noticed that anything coming after the codeblock is discarded as well. There's probably some weird edge cases where this causes turns things that are supposed to be code into named codeblocks, but it's probably not too much of a worry.

It would probably be feasible to somehow keep tracking of that leading whitespace before the codeblock starts, and then use that in the generation process.

Obviously haven't used this with whitespace-sensitive languages yet, as I mainly created this for large-scale C projects.

My worry is, even if I did implement this, idk how well it would actually work with the python ecosystem in practice. debugging code is one of pain points of working with tangled output. after a certain scale, you need to rely on line directives like what you can do in C. Having worked with other non-C languages in Worgle like Scheme and Janet, I can say from experience that it gets messy and frustrating quite quickly. It seems like there are some ways to do it in Python, but that's not something I really want to implement to work with Worgle.

[shakfu]

@PaulBatchelor thanks for the reply and explanation of the issue.

I agree that debugging whitespace sensitive code like python with literate programming tools can be messy. I have experienced this myself especially with unicode-related problems.

I think even in the case where one doesn't use a language like python, it would be nice to preserve indentation. Of course, you can sidestep this issue (since you are only tangling) by running something like clang-format after each tangle.