Only execute code blocks, like knitr?

[allefeld]

I am a longtime Pandoc user, and over time I have assembled for myself a semi-elaborate setup of Pandoc scripts and defaults files. They are fine-tuned to my (quite opinionated) opinions on how my documents should be rendered.

So far I use this to produce static (non-computational) documents. I would now like to integrate computational elements (make my texts notebooks), especially in Python and R, and looked for suitable preprocessing tools. Quarto seems to be close to what I need.

The idea would be:
[Markdown with executable code] → preprocessing → [Markdown with code output] → my Pandoc setup → [final document]
In R Markdown terms, I'm looking for something like knitr, not like render.

Or put differently, I'd like to get the Markdown which Quarto feeds into Pandoc.

I tried to achieve that by using quarto render ... --to markdown, and it is close, but not quite there:

• It modifies the YAML headers.
• It modifies parts of the Markdown which are not executable code.

I've also found quarto render ... --debug, which leaves the Markdown which Quarto feeds into Pandoc behind, but it feels strange to use a debug option for something not debugging-related; and it still performs the Pandoc call which is unnecessary for me.

Is there a way to achieve what I want?

[cscheid]

Take a .qmd file you're interested in and add keep-md: true to it. It will generate a slightly different .md file (specifically, it's the .md file we would have sent to pandoc). We don't currently have an option to stop our processing at that step, but if this file is closer to being useful for you, we could attempt to come up with a hack that works in your case.

[mcanouil]

You mean the following?

quarto render index.qmd --metadata keep-md:true

[allefeld]

Just tested it, and yes, the keep-md result is exactly what I need!

So the only thing that's missing would be a way to stop processing before Pandoc is called.

Is there any chance you would implement this, e.g. an option --knit-only?

I can also see whether I can get some code changes working myself, though I have limited experience with JS/TS development.
But if you could point me to the likely places changes would need to happen, or to a developer's guide or code guide if you have it, I'll try.

[cscheid]

@allefeld Right, we don't currently have a way to stop Pandoc from being called, but this is where we can come up with a hack. What we'll try to do is prevent the Quarto filter stack from executing as much as we can. What we will do is create a filter that runs before anything else from Quarto, and prevents quarto from seeing what you're producing.

Here's a first attempt:

keepmd.qmd

---
title: This is a keep-md test
format: md
filters:
  - keepmd.lua
  - quarto
---

# This is a title

This is some text.

Here is a [link](hello).

```{r}
1 + 2
```

keepmd.lua

local filter = {
  traverse = "topdown",
  Pandoc = function(doc)
    local output = pandoc.write(doc, "markdown")
    return pandoc.Pandoc({pandoc.RawBlock("markdown", output)}), false
  end,
}
return { filter }

Outputs

The keep-md output is:

---
title: This is a keep-md test
filters:
  - keepmd.lua
  - quarto
---



# This is a title

This is some text.

Here is a [link](hello).


::: {.cell}

```{.r .cell-code}
1 + 2
```

::: {.cell-output .cell-output-stdout}
```
[1] 3
```
:::
:::

The regular output with that filter is:

# This is a title

This is some text.

Here is a [link](hello).

::: cell
``` {.r .cell-code}
1 + 2
```

::: {.cell-output .cell-output-stdout}
    [1] 3
:::
:::

As you can see, we don't quite nail it, because we lost the metadata. But maybe this is a starting point for what you're trying to achieve. Pandoc also normalized some of the output (converting triple ticks to indented code blocks), but those are syntactically equivalent so hopefully you'll be ok. Finally, if you need the metadata, it is available in the doc object (doc.meta), but you'll need to do a bit more work to (eg) convert it back to YAML.

[allefeld]

Thanks for looking into this further!
But as you say, this is a hack...
It shouldn't be too hard to stop the Pandoc call, would it?

But maybe I misunderstand... From your examples it looks like quarto's knitting itself is implemented as a Pandoc filter. Is that the case?

Do you have a developer's guide which would explain such internals?

[cscheid]

From your examples it looks like quarto's knitting itself is implemented as a Pandoc filter. Is that the case?

quarto's knitting is not a pandoc filter; we invoke knitr first, and then send the output to quarto.

Do you have a developer's guide which would explain such internals?

Unfortunately, we don't. Quarto's internals are still moving too fast. It's in our medium-term plans for sure, but I don't have a timeline.