this.path (version 2.2.0)

progArgs: Providing Arguments to a Script

Description

withArgs() allows you to source() an R script while providing arguments. As opposed to running with Rscript, the code will be evaluated in the same session in an environment of your choosing.

fileArgs() / / progArgs() are generalized versions of commandArgs(trailingOnly = TRUE), allowing you to access the script's arguments whether it was sourced or run from a shell.

asArgs() coerces R objects into a character vector, for use with command line applications and withArgs().

Usage

asArgs(...)
fileArgs()
progArgs()
withArgs(...)

Value

for asArgs(), fileArgs(), and progArgs(), a character vector.

for withArgs(), the result of evaluating the first argument.

Arguments

...

R objects to turn into script arguments; typically logical, numeric, character, Date, and POSIXt vectors.

for withArgs(), the first argument should be an (unevaluated) call to source(), sys.source(), debugSource() in ‘RStudio’, compiler::loadcmp(), knitr::knit(), testthat::source_file(), or a source()-like function containing set.sys.path() / / wrap.source().

Details

fileArgs() will return the arguments associated with the executing script, or character(0) when there is no executing script.

progArgs() will return the arguments associated with the executing script, or commandArgs(trailingOnly = TRUE) when there is no executing script.

asArgs() coerces objects into command-line arguments. ... is first put into a list, and then each non-list element is converted to character. They are converted as follows:

Factors (class "factor")

using as.character.factor()

Date-Times (class "POSIXct" and "POSIXlt")

using format "%Y-%m-%d %H:%M:%OS6" (retains as much precision as possible)

Numbers (class "numeric" and "complex")

with 17 significant digits (retains as much precision as possible) and "." as the decimal point character.

Raw Bytes (class "raw")

using sprintf("0x%02x", ) (for easy conversion back to raw with as.raw() or as.vector(, "raw"))

All others will be converted to character using as.character() and its methods.

The arguments will then be unlisted, and all attributes will be removed. Arguments that are NA_character_ after conversion will be converted to "NA" (since the command-line arguments also never have missing strings).

Examples

this.path::asArgs(NULL, c(TRUE, FALSE, NA), 1:5, pi, exp(6i),
    letters[1:5], as.raw(0:4), Sys.Date(), Sys.time(),
    list(list(list("lists are recursed"))))


FILE.R <- tempfile(fileext = ".R")
this.path:::.write.code({
    this.path:::.withAutoprint({
        this.path::sys.path()
        this.path::fileArgs()
        this.path::progArgs()
    }, spaced = TRUE, verbose = FALSE, width.cutoff = 60L)
}, FILE.R)


## wrap your source call with a call to withArgs()
this.path::withArgs(
    source(FILE.R, local = TRUE, verbose = FALSE),
    letters[6:10], pi, exp(1)
)
this.path::withArgs(
    sys.source(FILE.R, environment()),
    letters[11:15], pi + 1i * exp(1)
)
this.path:::.Rscript(c("--default-packages=NULL", "--vanilla", FILE.R,
    this.path::asArgs(letters[16:20], pi, Sys.time())))
## fileArgs() will be character(0) because there is no executing script
this.path:::.Rscript(c("--default-packages=NULL", "--vanilla",
    rbind("-e", readLines(FILE.R)[-2L]),
    this.path::asArgs(letters[16:20], pi, Sys.time())))


# ## with R >= 4.1.0, use the forward pipe operator '|>' to
# ## make calls to withArgs() more intuitive:
# source(FILE.R, local = TRUE, verbose = FALSE) |> this.path::withArgs(
#     letters[6:10], pi, exp(1))
# sys.source(FILE.R, environment()) |> this.path::withArgs(
#     letters[11:15], pi + 1i * exp(1))


## withArgs() also works with set.sys.path() and wrap.source()
sourcelike <- function (file, envir = parent.frame())
{
    file <- set.sys.path(file)
    envir <- as.environment(envir)
    exprs <- parse(n = -1, file = file)
    for (i in seq_along(exprs)) eval(exprs[i], envir)
}
this.path::withArgs(sourcelike(FILE.R), letters[21:26])


sourcelike2 <- function (file, envir = parent.frame())
{
    envir <- as.environment(envir)
    exprs <- parse(n = -1, file = file)
    for (i in seq_along(exprs)) eval(exprs[i], envir)
}
sourcelike3 <- function (file, envir = parent.frame())
{
    envir <- as.environment(envir)
    wrap.source(sourcelike2(file = file, envir = envir))
}
this.path::withArgs(sourcelike3(FILE.R), LETTERS[1:5])
this.path::withArgs(wrap.source(sourcelike2(FILE.R)), LETTERS[6:10])


unlink(FILE.R)