opts_chunk - knitr echo true

knitr-excluye trozos de `purl(…)`?

Question

Cuando formo / enredo un documento para extraer los trozos R en un script, ¿hay alguna manera de:

• ¿Excluir un trozo arbitrario (por nombre decir)?
• si no, excluya un trozo si eval=F (o tal vez puedo definir un trozo / opción include=F )?

Por ejemplo, supongamos que tengo el siguiente Rmd:

```{r setup, echo=F}
library(MASS)
```
First, we perform the setup (assume for some reason I need to evaluate `setup`
silently before I wish to display the chunk to the user, hence the repetition)
```{r setup, eval=F}
```
Here''s the function I''ve been explaining:
```{r function}
plus <- function (a, b) a + b
```
And here''s an example of its use:
```{r example}
plus(1, 2)
```

El script enredado se ve así:

## @knitr setup, echo=F
library(MASS)
## @knitr setup, eval=F
library(MASS)
## @knitr function
plus <- function (a, b) a + b
## @knitr example
plus(1, 2)

Tengo la idea de que, como no quería que se evaluaran fragmentos particulares, al menos no deberían aparecer en la salida (en el ejemplo anterior, el segundo fragmento de setup ).

Además, sería bueno para mí marcar algunos trozos como "invisibles" con respecto a la salida enredada. No quiero el fragmento de example en mi script de salida (fue bueno en Rmd para fines de documentación, pero quiero poder enredar el Rmd y luego solo la source(''myfile.r'') si deseo usar La función plus , sin tener que preocuparme por la ejecución de estos ejemplos adicionales. Actualmente, enredo el Rmd y luego edito manualmente los fragmentos que no quiero del script, lo que parece contrario al principio de solo escribir el Rmd que proporcionará Tanto la documentación como el guión sin esfuerzo adicional.

Answer 1

Aunque esto es más un truco que una solución, aún puede modificar el script resultante de purl con algunas expresiones regulares.

Por ejemplo, con la siguiente función (quizás haya una solución más simple para la expresión regular):

dropchunks <- function(scriptname, what.to.drop){
script <- readLines(scriptname)
script <- do.call(paste, list(script, collapse = "/n") )
subpattern = paste0("(", do.call(paste, list(what.to.drop, collapse="|")), ")")
mainpattern <- paste(''(?s)## @knitr ((?!## @knitr).)*?'', subpattern, ''.*?((?=## @knitr)|$)'', sep="")
script <- gsub(pattern = mainpattern, replacement = "", x = script, perl=TRUE)
writeLines(text = script, con= scriptname)
}

Luego puede hacer esto para eliminar todo el fragmento de código que contiene eval = F:

library(knitr)
purl("test.Rmd")
dropchunks("test.R", "eval=F")

Puede hacer esto para eliminar el fragmento denominado "función" o "ejemplo" (y de hecho eliminará cualquier fragmento que contenga estas palabras en algún lugar, pero esto podría cambiarse cambiando la expresión regular):

purl("test.Rmd")
dropchunks("test.R", c("function", "example"))

Answer 2

Desde knitr 1.3, hay una nueva opción de fragmento purl = TRUE/FALSE que permite incluir / excluir ciertos fragmentos de código para purl() .

```{r test, purl=FALSE}
library(MASS)
```

Answer 3

El bloque de procesamiento de enredos actualmente no amplía los parámetros, pero podemos hacer que lo haga ...

# See `?trace` documentation for details.
bdy <- as.list( body( knitr:::process_tangle.block ) )
trace.at <- which( grepl(".*opts_chunk//$merge.*",
as.list( body( knitr:::process_tangle.block ) ) ) )
tracer <- quote({
# Code borrowed from normal chunk procesing.
af = opts_knit$get(''eval.after''); al = opts_knit$get(''aliases'')
if (!is.null(al) && !is.null(af)) af = c(af, names(al[af %in% al]))
for (o in setdiff(names(params), af)) params[o] = list(eval_lang(params[[o]]))
# Omit this if using lastest knitr source from github.
if( isFALSE( params$include ) ) {
tmp <- knit_code$get();
tmp[[params$label]] <- "";
knit_code$restore(tmp)
}
})
trace( knitr:::process_tangle.block, tracer=tracer, at=trace.at, print=FALSE )

Entonces la exclusión de purl () puede ser controlada usando argumentos de opción ...

```{r setup, echo=TRUE, results=''hide''}
library(MASS)
````
First, we perform the setup (assume for some reason I need to evaluate `setup`
silently before I wish to display the chunk to the user, hence the repetition)
```{r setup2, ref.label="setup", echo=FALSE, results=''markup''}
```
Here''s the function I''ve been explaining:
```{r function}
plus <- function (a, b) a + b
```
And here''s an example of its use:
```{r example, eval=!opts_knit$get("tangle") }
plus(1, 2)
```
And here''s another example of its use:
```{r example2, include=!opts_knit$get("tangle") }
plus(3, 3)
```