Prevent chunk options from ending up in HTML source?

[richarddmorey]

Description

If we have the following qmd file:

---
title: "Untitled"
format: html
---


```{r}
#| mySetting: 'hi there'
1 + 1
```

...when I render it and look at the source, I see:

<div class="cell" data-mysetting="hi there">
<div class="sourceCode cell-code" id="cb1"><pre class="sourceCode r code-with-copy"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="dv">1</span> <span class="sc">+</span> <span class="dv">1</span></span></code><button title="Copy to Clipboard" class="code-copy-button"><i class="bi"></i></button></pre></div>
<div class="cell-output cell-output-stdout">
<pre><code>[1] 2</code></pre>
</div>
</div>

In particular, there is a div that has a data attribute (data-mysetting) equal to my chunk setting (hi there). There are cases where chunk options might contain information I do not want in the source (but want to be available when using knitr hooks, for instance) and I'd like to disable it.

How can I prevent information from leaking from the chunk options into the compiled source?

[cderv]

Indeed, we only consider known knitr and Quarto options - all other options are passing through and considered attributes on the code block.

We would need to have a way to pass information to quarto of what chunk options should be considered as option for knitr only. We'll think about that.

I believe for now you could create a Lua filter (https://quarto.org/docs/extensions/filters.html) that would catch your known options and remove them, so that they don't end up in the output.

[richarddmorey]

Thanks, I'll take a look at that. In the mean time, is there a way I can detect in R whether the knitr hook is being run in a quarto document so I can use stop() (or at least throw a warning()) when the hook is run?

[cderv]

Not sure I am following. You could add the warning inside your hook function, couldn't you ?

Quarto will run knitr, and knitr will run any hook defined. So I guess your hook will be run. BTW, are you talking of your specific option hook ?

[mcanouil]

Would it be possible to have a more detailed overview of your use case? mySetting in your case seems a lot like parameters to me, but kind of using your own implementation.

[richarddmorey]

For other people's reference, this lua filter seems to work:

if FORMAT:match 'html' then
  function Div (elem)
    elem.attributes.mySetting = nil
    return elem
  end
end

Edited to add: it seems the attribute's capitalization has to be like the original, not as it appears in the html output.

[cscheid]

A slightly more "quarto-ish" way to do it would be to check for html-like formats (so you'd catch related formats like revealjs and custom formats that are based on HTML, etc):

if quarto.doc.is_format('html') then
  function Div (elem)
    elem.attributes.mysetting = nil
    return elem
  end
end

[richarddmorey]

Would it be possible to have a more detailed overview of your use case? mySetting in your case seems a lot like parameters to me, but kind of using your own implementation.

Sure, I've written some knitr hooks that take the output (or source) from a chunk and puts an encrypted div in the HTML document. The knitr hook looks for specific chunk options, the content of which is the key; eg,

```{r}
#| output_encrypt: 'mykey'

plot(1:10)
```

would lead to an encrypted div with the plot in it. There's some javascript that gets injected for decrypting it when you input the correct key.

This all works fine in Rmarkdown and Quarto, except that in Quarto the divs have the chunk option in them; which means that the key is sitting in the document (obviously not good).

In general, because I work with educational material, it is often useful not to have some information about how the document was compiled in the resulting compiled document.

Could we, say, do something like the following (note the double pipe) to indicate that the chunk option should not be passed into the rendered document?

```{r}
#|| output_encrypt: 'mykey'

plot(1:10)
```

[mcanouil]

Would it not be easier to simply use params which allows you to pass them via Quarto CLI inline or via a YAML file?

---
title: "Untitled"
format: html
params:
  secret: false
  mySetting: 'hello'
---

```{r}
#| include: false
knitr::knit_hooks$set(output = function(before, options, envir) {
  if (params[["secret"]]) {
    paste0(before, "\n\nMy setting is secret ...")
  } else {
    paste0(before, "\n\nMy setting is: ", params$mySetting)
  }
})
```

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

[richarddmorey]

No, because then you can't change it per chunk. The secret can be different for different chunks.

[richarddmorey]

Perhaps a concrete example would help. Here's an Rmd file that will have encrypted content with the output of the chunks. In a didactic setting, you might give one key that decrypts the questions at time 1, then another key that decrypts the answers, at time 2. All of this might be contained in one document.

---
title: "Encrypted document test"
author: "Richard D. Morey"
date: "`r Sys.Date()`"
output: encryptRmd::html_document_enc

---

```{r setup, include=FALSE}
knitr::opts_chunk$set(echo = TRUE)
```

> This is a slightly extended version of the basic Rmarkdown template, but containing encrypted output. Enter the key 'key1' to see the summary table output, and 'key2' to see the plot output.

## R Markdown

This is an R Markdown document. Markdown is a simple formatting syntax for authoring HTML, PDF, and MS Word documents. For more details on using R Markdown see <http://rmarkdown.rstudio.com>.

When you click the **Knit** button a document will be generated that includes both content as well as the output of any embedded R code chunks within the document. You can embed an R code chunk like this:

```{r cars, output_encrypt = 'key1'}
summary(cars)
```

## Including Plots

You can also embed plots, for example:

```{r pressure, echo=FALSE, output_encrypt = 'key2'}
plot(pressure)
```

Note that the `echo = FALSE` parameter was added to the code chunk to prevent printing of the R code that generated the plot.

[cderv]

This is definitely a classic knitr example using custom option hooks. We need indeed to find a way to make the process easier to register some options as knitr chunks options.

Custom Lua filter is for now the best way to solve this use case.