runs code with all environment variables unset, can be useful for testing.

As it is entirely useless 🙊

Make use of https://github.com/gaborcsardi/disposables

with_temp_package <- function(packages, code, ...) {
  pkg <- disposables::make_packages(packages, ...)
  on.exit(disposables::delete_packages(pkg))
  force(code)
}

To be consistent with rlang.

Withered vine spelling withr was my thought...

SWIM has some unit tests that loop over combinations of argument values for a function and call a print method and just check that no errors are thrown. The printing causes a bunch of output I don't particularly want to appear on the console when I use testthat::test_file() and also creates a bunch of output in the travis-CI log files I don't want either. I was hoping I could use with_output_sink() to still run the tests, but without all the annoying output. Unfortunately, this causes an error in a very innocuous looking part of the code that I can't reproduce if I remove the call to with_output_sink(). The test file is here.

  with_envvar_unset <- withr::with_(
    function(x) {
      old <- Sys.getenv(x, names = TRUE)
      Sys.unsetenv(x)
      old
    },
    Sys.setenv
  )

Integrating this into with_envvar() is another option: Unset all elements that are NULL. Interface becomes incompatible with Sys.setenv() but this is not necessarily a bad thing.

Fails with r-lib/devtools@89e7bfd1d5e, succeeds with CRAN devtools 1.9.1.

Loading withr
Error in imp_env$system.file <- shim_system.file : 
  cannot add bindings to a locked environment
2: insert_imports_shims(pkg)
1: devtools::load_all(".")

Need to mention them in the function level documentation of withr and have examples of local_ in the README.md and in ?withr at least.

I'm looking for a clean way to run examples that call other packages without injecting library() calls. Would rather avoid using ::.

Very rough sketch:

with_require <- with_(add_to_search, restore_search)

add_to_search <- function(pkg) {
  old_search <- search()
  pkg_id <- rev(paste0("package:", pkg))
  lapply(pkg_id, add_to_search_one)
  old_search
}

add_to_search_one <- function(pkg) {
  if (pkg %in% search()) {
    detach(pkg)
  }
  require(pkg, quietly = TRUE)
}

restore_search <- function(old_search) {
  ...
}

Possible extension: Generic environments, as in

with_require(list(env1 = new.env()), ...)

Thoughts?

This was a no-go for devtools, but I think in this package it would be better. The list of all functions is the package index. ?

Hadley suggested wither, or maybe withr, which is pretty clever!

See discussion in #29. Will also help #27.

Neither of these files have any calls in them, so they are not counted in the coverage.

This is due to covr tracking coverage on objects defined in the package environment rather than parsing the expressions in the file directly.

Regardless we should add tests for them!

If you set CNAME to withr.r-lib.org we have a wildcard DNS to make it work automatically.

Hi, I have an issue using with_option to launch a shiny app with the correct option

I dont understand why this code doesn't work as expected :

library(shiny)

ui <- fluidPage(
  verbatimTextOutput("option"),
  verbatimTextOutput("option2"),
  actionButton("go","go")
)

server <- function(input, output, session) {
  output$option <- renderText({getOption("repos")})
  output$option2 <- renderText({ getOption("shiny.maxRequestSize") })
}

withr::with_options(list(shiny.maxRequestSize="find_me"), {
  shiny::shinyApp(ui, server)
})

this app should show "find_me" inside a textouput do I make a typo? getOption("shiny.maxRequestSize") have to be 'find_me', why not?

I certainly can add this option inside the server, but I prefere to use with_option.

It's a bit unfortunate that the latest version of devtools no longer works on R 3.1.x. Is there a way we can make withr work on R 3.1, at least until R 3.3 is out?

It's not really a with function, more a constructor. How about make_with?

For code that needs to create a large number of temporary files, it may be more convenient to create a single temporary directory, create any files it needs to in that directory, and then recursively delete that directory when it finishes. I suggest a function with_temp_dir that encapsulates this pattern. It would work like Python 3's tempfile.TemporaryDirectory context manager.

Implementation can be simple as

with_env <- function(code, env = new.env()) {
  base::with(new.env(...), code)
}
with_env({a <- 1;print(a)})
#> [1] 1
a
#> Error: object 'a' not found

Useful for test setup, temporary variables you don't want to cleanup ect.

To run some code with a temporary random seed. Useful for testing.

This might seem nitpicking in R, but I think it is important to learn good practice in general. Whenever you write things like

restore <- change_something()
on.exit(restore_something(restore), add = TRUE)
...

you introduce a potential error. If the code is interrupted after change_something, but before on.exit, then restore_something will never happen.

Here is an example from devtools:
https://github.com/hadley/devtools/blob/c2ad0729e56990b5c66a4e1ef50f3aaa2b8b9c5a/R/with.r#L36-L41

This is of course everywhere, in base R and CRAN packages, not just in devtools. I think in most cases you can just do something like:

on.exit(try(restore_something(restore)), add = TRUE)
restore <- change_something()
...

i.e. just switch the order of the two expressions, and add a try(), in case there is an interruption after on.exit(), but before change_something().

with_device

For saving base/lattice graphics. Need to call dev.off on exiting.

I think that you get clearer code by having a different function for each device type, for example

with_png <- function(new, code)
{
  do.call(png, as.list(new))
  on.exit(dev.off())
  force(code)
}

with usage like

with_png("test.png", plot(1:10))
with_png(list("test2.png", width = 800, height = 600), plot(1:10))

You also need with_tiff, with_pdf, etc.

with_connection

For file connections. Need to call close on exiting.

This needs some thinking about. I want to write

with_file <- function(new, code)
{
  conn <- do.call(file, as.list(new))
  on.exit(close(conn))
  # How to pass conn to the code?
  force(code)
}
with_file(list("test.txt", open = "w"), writeLines(LETTERS))

But you need to figure out the best way to pass the connection to writeLines/readLines/cat/whichever other function uses the connection.

with_db_connection

Using dbConnect and on.exit(dbdisconnect), but again you need a way to pass the connection to the code.

Based on code I wrote a while ago to accomplish a similar thing, I'd like to suggest an actual with_dev function:

## Returns TRUE if x refers to the device number of a currently active
## graphics device.
library(rlang)
library(assertthat)
is_dev <- function(x) {
    is_scalar_integer(x) && x %in% dev.list()
}

with_dev <- function(dev, code, closedev) {
    orig.device <- dev.cur()
    new.device <- force(dev)
    # Functions that create devices don't generally return them, they
    # just set them as the new current device, so get the actual
    # device from dev.cur() instead.
    if (is.null(new.device)) {
        new.device <- dev.cur()
    }
    assert_that(is_dev(new.device))
    message(glue("Orig device: {deparse(orig.device)}; new device: {deparse(new.device)}"))
    if (missing(closedev)) {
         closedev <- new.device != orig.device
    }
    on.exit({
        if (closedev) {
            dev.off(new.device)
        }
        if (is_dev(orig.device)) {
            dev.set(orig.device)
        }
    })
    force(code)
}

# Usage:
library(ggplot2)
with_dev(pdf(file.path(tempdir(), "test.pdf")), print(qplot(x=1:50, y=rnorm(50))))

The dev argument should either be code that returns a graphics device, or code that creates a new graphics device, sets it as the current device, and returns NULL. (Functions like png, pdf, etc. fall into the latter category.)

The function tries to auto-detect whether or not is should close the device when done with it. The heuristic is that if evaluating dev changes the value of dev.cur(), then the device will be closed on exit. This can be overridden with the closedev argument.

The is_dev function is just a helper here, but it might be worth including in rlang, named something like is_graphics_device.

My original code: https://github.com/DarwinAwardWinner/CD4-csaw/blob/master/scripts/utilities.R#L143-L169

This code errors when run as is, but works when library(withr) is called first. defer, however, does not have this problem.

scoped_temp_file <- function(path) {
    fs::file_create(path) 
    withr::defer_parent(fs::file_delete(path))
}

testthat::test_that("file changes", {
    scoped_temp_file("file.txt")
})
#> Error: Test failed: 'file changes'
#> * could not find function "defer"
#> 1: scoped_temp_file("file.txt") at <text>:7
#> 2: withr::defer_parent(fs::file_delete(path)) at <text>:3
#> 3: eval(substitute(defer(expr, envir, priority), list(expr = substitute(expr), envir = parent.frame(2), 
#>        priority = priority)), envir = parent.frame())
#> 4: eval(substitute(defer(expr, envir, priority), list(expr = substitute(expr), envir = parent.frame(2), 
#>        priority = priority)), envir = parent.frame())

cc @jimhester

With

library(withr)
f <- function(...) { cat("f\n"); 1 }
options(error = f)
g <- function() {
    local_options(list( error = function(...) { cat("g\n"); 2 } ))
    3
}

the evaluation of f() can be seen by the side-effect

> g()                                     # side-effect
f
[1] 3

The failure to re-establish the original handler is seen with

> options("error")                        # local option not removed
$error
(function (...) 
{
    cat("g\n")
    2
})()

The problem is in the call to set_options when returning from g()

> withr:::set_options
function (new_options) 
{
    do.call(options, as.list(new_options))
}

where do.call() evaluates as.list(new_options).

The problem came up in the context of RUnit (setting the equivalent of f() to report the traceback on error) and batchtools @mllg playing the role of g()

> head(batchtools:::execJob.Job, 3)
1 function (job)                                            
2 {                                                         
3     local_options(list(error = function(e) traceback(2L)))

So in devtools it has person("RStudio", role = "cph"), which assigns RStudio the copyright as both @hadley and @wch are employed by Rstudio.

While much of the code in this package was originally derived from code in devtools it has been fairly substantially reworked by @krlmlr and I. I think we should definitely keep Hadley and Winston as authors and attribute the original source of the code to devtools, however I am not sure if RStudio should still be listed as the copyright holder as neither Kirill or I is associated with them.

If it is decided that RStudio should remain the copyright holder that is fine with me, but I wanted to get some input before we submit withr to CRAN.

This takes an idea from bquote() and allows you to specify what variable to assign the temporary filename to in your code by surrounding it in a .() call. Then these files are cleaned up afterwards. The function definition and example usage is below. An alternative interface would be to have a separate argument to specify variable names to use, but I think it is a little nicer to specify them inline. Any thoughts @krlmlr?

with_tempfile <- function(code, envir = parent.frame()) {
  # Adapted from bquote
  vars <- character()
  unquote <- function(e) {
    if (is.pairlist(e))
      as.pairlist(lapply(e, unquote))
    else if (length(e) <= 1) e
    else if (e[[1]] == as.name(".")) {
      vars <<- append(vars, as.character(e[[2]]))
      e[[2]]
    }
    else as.call(lapply(e, unquote))
  }
  code <- unquote(substitute(code))
  if (length(vars) == 0) {
    stop("Must specify a variable to store the temp filename using .() in your
         code", call. = FALSE)
  }

  env <- new.env(parent = envir)
  for (var in vars) {
    assign(var, tempfile(), envir = env)
  }
  on.exit(unlink(mget(vars, envir = env)))

  eval(code, envir = env)
}

files <- character()

with_tempfile({
  writeLines("hi", con = .(tmp))
  writeLines("ho", con = .(tmp2))
  print(readLines(tmp))
  print(readLines(tmp2))
  files <<- append(files, tmp)
  files <<- append(files, tmp2)
})
#> [1] "hi"
#> [1] "ho"

readLines(files[1])
#> Warning in file(con, "r"): cannot open file '/tmp/RtmpjcsoCQ/
#> filecc56011eda5': No such file or directory
#> Error in file(con, "r"): cannot open the connection
readLines(files[2])
#> Warning in file(con, "r"): cannot open file '/tmp/RtmpjcsoCQ/
#> filecc52fad8b97': No such file or directory
#> Error in file(con, "r"): cannot open the connection

It occurs to me that the first argument could default to tempfile() and the path could be returned

This might be a useful pattern elsewhere - with_*() can't easily pass a value into the block (unless we use NSE or require anonymous functions), but local_ doesn't have the same problem.

Requiring R (>= 3.2.0) in the DESCRIPTION is more restrictive than devtools (currently R (>= 3.0.2)).
Is that really necessary?

e.g. get_seed() uses get0() which apparently doesn't exist in 3.1.

for testing.

with_gctorture2 <- with_(gctorture2)

• with_path
• with_libpaths
• with_temp_libpaths (#1)
• Deprecate with_lib

See https://github.com/hadley/devtools/pull/833/files#r31861098.

I am picturing a function that reaps zombie children on error, something like the following.

with_cluster <- function(cl, code){
  withCallingHandlers(
    code,
    error = function(e){
      parallel::stopCluster(cl)
      stop(e)
    }
  )
}

library(withr)
getOption("undefined")
## NULL
with_options(new = list(some_other_option = 5), {
  options(undefined = "user_defined")
})
getOption("undefined")
## "user_defined"

Do we want to restore all the options, not just those in new?

For with_tempfile(), with_connection() and with_db_connection(). See also discussion in #29.

Need to find or create a package that implements a mutable stack.

Do we need to distinguish by type, for nested calls, so that we can ask "give me the innermost object of type x"?

The with version is just withCallingHandlers(), but a local_ one would also be interesting...

First, on windows, we should use Makevars.win, if it exists. Assuming R can use a user or system level Makevars.win file at all.

Second, if R_USER_MAKEVARS is already set to a file, we should probably use that as the basis.

I'm imaging a case where you're writing a function that attempts to write a file at some location, but restores the old copy (filesystem state) if something goes wrong during update. E.g.

with_backup <- function(file, expr) {
  
  backup <- tempfile(
    pattern = sprintf(".backup-%s-", tools::file_path_sans_ext(basename(file))),
    tmpdir = dirname(file),
    fileext = paste0(".", tools::file_ext(file))
  )
  
  file.rename(file, backup)
  on.exit({
    if (file.exists(file))
      unlink(backup)
    else
      file.rename(backup, file)
  })
  
  force(expr)
}

Something like:

destruct <- function(x){
  UseMethod("destruct")
}

volatile <- function(x){
  defer_parent(destruct(x))
  x
} 

Then a class could define the S3 method for destruct ...

The goal is to enable writing, instead of this,

with_dir(directory, {
    // code
})

to write this:

scoped_dir(directory)
// code

This can be accomplished with a couple tools. The main trick is to use on.exit, but attach its execution to an arbitrary parent frame. We create a function defer that accomplishes that:

defer <- function(expr, envir = parent.frame()) {

  # Create a call that must be evaluated in the parent frame (as
  # that's where functions and symbols need to be resolved)
  call <- substitute(
    evalq(expr, envir = envir),
    list(expr = substitute(expr), envir = parent.frame())
  )

  # Use 'do.call' with 'on.exit' to attach the evaluation to
  # the exit handlers of the selected frame
  do.call("on.exit", list(substitute(call), add = TRUE), envir = envir)

  # TODO: Not sure what we should actually return.
}

And then create functions that provide their 'state' and 'reset' at the exit of that scope:

scoped_dir <- function(directory) {
    owd <- setwd(directory)
    defer(setwd(owd), parent.frame())
}

Any thoughts on whether something like this would be appropriate for withr?

For completeness, this was inspired by the discussion here: https://stat.ethz.ch/pipermail/r-devel/2013-November/067874.html

The .R/Makevars is useful for setting compile flags; setting them temporarily is a pain.

To avoid overwriting an existing file, we could

1. create /tmp/home-xxxx and there create a symlink for everything in $HOME except .R/Makevars
2. create /tmp/home-xxxx/.R/Makevars, with an optional -include /old/home/.R/Makevars
3. set the HOME environment variable to /tmp/home-xxxx
4. run the code
5. undo everything

CC @gaborcsardi

with_message_sink() deliberately avoids creating two message sink()s on the same file. I am wondering if you might consider relaxing this behavior somehow, maybe with something like with_message_sink(..., allow_multiple = TRUE). See this SO post for a use case that would greatly benefit.

lattice was moved from Suggests to Imports in 26a2ddf, but it seems like it may not be used. The CRAN check log says it's not imported from.

A search shows it only used in tests/testthat/test-devices.R, so maybe it was an accident.

@krlmlr Could you look at the with_message_sink tests at

These tests have actually failed for me locally even with the previous testthat, but were working on travis and appveyor.

See r-lib/devtools#833.