Can I access the chunk info (such as line number) before rendering?

[etiennebacher]

Description

I am building a gallery of plots with Quarto using the lightbox extension. One thing that would be nice is to show the link to the code chunk that created a particular plot when the user clicks on the plot.

For example, I have the following document:

---
lightbox: true
execute:
  echo: false
---

```{r}
#| lightbox:
#|   group: r-graph
#|   description: "[Code](<PATH TO REPO>/gallery.qmd#L7)"
plot(iris)
```

```{r}
#| lightbox:
#|   group: r-graph
#|   description: "[Code](<PATH TO REPO>/gallery.qmd#L14)"
plot(mtcars)
```

When the user clicks on a plot, the link to the code appears in the description (the link doesn't work because of the invalid path, but it works with a real link). As you can see, the line numbers in the link (L7 and L14) are hardcoded, meaning that I will have to change them by hand if I add lines above the chunks, and this can be tedious if there are many plots.

Therefore, is there a way to know automatically the line number at which a chunk starts and use this info? No clue if that would work but I have in mind something like description: "[Code](<PATH TO REPO>/gallery.qmd#L{r get_chunk_line_number()})".

[mcanouil]

You want a line to know where it is located? That's not possible without static code analysis.
You can probably write a Lua filter, or at least post-render script.

There is also code-line-numbers which will generate a unique IDs for each lines in the rendered document, not the source though, but you still need to figure out the ID when writing (i.e., #cb<number>-<line>), so either you render twice or you write something to do that for you. Note that it's for HTML.

[cderv]

As more context, source lines are tracked internally so that quarto can correctly give information about where an error is thrown. This is far from perfect and this is done by engine and possibly with quarto fixup (as internal source can be different).

However, this is not exposed easily today. To have something like {r get_chunk_line_number()})" this is definitely an engine thing, and so should be looked at in knitr which already consider line numbers to report errors.

Something to experiment there probably. PR welcome in knitr if you have a proposal to expose internal nicely.

Otherwise, post processing idea as shared above could be working well for your specific use case. You would probably need some sort of identifiers on plots so that you can match source line with HTML output in the document.

Playing with pre-render script to create a JSON representation of you source document mapping to line number and then JS script in your document to process the JSON and add the description could be another idea. Or processing through Lua to add before HTML rendering.

Anyway, a lot to play with for a fun project 😄

I'll be interest in your results 😉 - I am not sure we can provide some more help with this any time soon unfortunately. 😞

[etiennebacher]

Thanks for your answers @cderv and @mcanouil!

I've moved to a simpler solution which is simply to store the script and image in an external folder and then do something like:

```{r}
#| lightbox:
#|   group: r-graph
#|   description: "[Code](<path to repo>/fig/gallery_01.R)"
knitr::include_graphics("../fig/gallery_01.png")
```

for each plot. It's a bit more manual but I don't want to overengineer this.

[cderv]

Nice solution !

You could also do something like

```{r}
#| lightbox:
#|   group: r-graph
#|   description: "[Code](<path to repo>/fig/gallery_01.R)"
#| file: fig/gallery_01.R
``` 

so that you plot is produced by your code without a pre-rendering step

See about this knitr option at: https://bookdown.org/yihui/rmarkdown-cookbook/option-code.html

I think this should work

[etiennebacher]

Nice, thank you 👍