Is it possible to source a lua filter from an R package?

[pingfan-hu]

Description

My Question

Hi there! I wonder if there is a way to source the lua filter(s) from an R package.

Currently, we have 2 ways of sourcing a lua filter:

1. From a Quarto extension
2. From a local lua file in our Quarto project

Now I'm building an R package and wonder if it's possible to source a lua filter from it. I know there is an inst folder that can store files. I wanted to store my desired lua filter into this folder and source it in my Quarto doc, but it was not successful. Does anyone have experience on that?

Example

To explain it better, here is a simple example of using the "code-visibility" Quarto extension.

Firstly, to install it, run in your Terminal:

quarto install extension jjallaire/code-visibility

Then, render this example Quarto doc:

---
title: "Quarto ext example usage"
filters:
  - code-visibility
---

```{r}
# This line can be shown:
visible_line <- "Hi! I am visible!"

# This line is hidden by using this filter:
i_am_invisible  <- "You are not supposed to see me!" #| hide_line
```

In the output HTML page, you can see the line of i_am_invisible is hidden due to #| hide_line. This is made possible by introducing the code-visibility extension in the YAML header. You can also extract the lua filter of this extension, save it in your local project, and source it.

Then, back to my own R package development question, I wonder if I can have a lua filter in my R package, so that as long as it's installed, I can source it using filter or some other YAML command, or source it using R code scripts. If anyone has experience on that, please teach me how.

Thanks!

[gordonwoodhull]

I think you are probably running into the limitation that a quarto document can't look outside its project directory.

This is for reproducibility - all inputs must come from the project or document directory. So although you can run R and Python from packages, you can't currently do that with Lua, so you must copy Lua filters into the project directory.

So you need to make a Quarto extension that installs the Lua filters that your R package needs.

Others probably know whether it's possible to have a combined R package / Quarto extension so you can develop them in one repo. Worst case it's two project repos.

[mcanouil]

That's pretty much the answer.

The "workaround" is to use renv for example to create the R library inside your Quarto project.
The. You can get the path to the LUA filter from R: system.file(package = "my.pkgs").

Why would you share a LUA filter inside an R package rather than as a Quarto extension?

[jhelvy]

Why would you share a LUA filter inside an R package rather than as a Quarto extension?

I can add some context to this question. @pingfan-hu used a simple example here as it's easy to reproduce and explain. But the motivation for this is rooted in a project we are both working on.

We are developing a Quarto-based survey platform called surveydown, which has an R package and Quarto extension to make it all work. The extension originally had just one lua filter that handled a few things, like loading JS files, etc. This just make things cleaner for users so they only needed to include the extension in the qmd yaml. But as the package evolved, we moved this main lua file into the package itself and updated the extension lua file to be a wrapper that simply loads the main lua file that lives inside the R package. The reason we did this was because from now on as the R package evolves we only need to update the main lua file, not the extension wrapper. It makes version control easier because we can ensure that the main lua file is properly up to date with the R package without users needing to also go update their extension lua file.

Imagine how this works in practice. Let's say you have dozens of surveys in separate projects. When the R package updates, you just re-install the package and all the surveys are up to date. Without this architecture, you'd have to go update the extension in each of those projects as well to enable the latest features.

This is a broader concern / issue I have with Quarto extensions in general, which is that they're tricky to version control since they are always local to a project. I would love to have a way to install them globally like R packages, but that is a larger architecture question for Quarto. For now, our "fix" to have something like a globally-installed extension is to make an extension a wrapper that sources from an R package.

Ideally, we would like to not even need the extension wrapper. Imagine if we could call R code in the yaml like this:

---
server: shiny
filters: `r system.file('quarto/filters', 'main.lua', package = 'surveydown')`
---

Then you could also imagine making a function in the package that runs this, something like this:

sd_load_extension <- function() { system.file('quarto/filters', 'main.lua', package = 'surveydown') }

And the yaml would be:

---
server: shiny
filters: `r surveydown::sd_load_extension()`
---