Suppress install outputs in R

Question

This is really starting to bug me...I have tried a few methods and none seem to work

I am running an install from a function which generates a lot of unnecessary messages that I would like to suppress, but all of the methods I tried to do this have not worked.

The bit of code I am trying to suppress is : install_github('ROAUth', 'duncantl'), it requires the package devtools to be loaded beforehand.

Anyway, I tried invisible, capture.output and sink, none of which work...or perhaps I am not using them correctly... either way...any ideas?

Answer 1

suppressMessages will turn some messages off (those that were printed though calls to message), but not all.

The rest of the messages are coming from a shelled out call to R CMD INSTALL via the system2 function. I think it is because this is shelled out that all the usual things you tried (sink, capture.output, etc.) are not working. Note that the system2 function comes with stderr and stdout arguments which, if turned to FALSE would turn off all those messages. Unfortunately, system2 uses stdout = "" and stderr = "" by default and there seems to be no way to access these arguments through the devtools package.

So one way I managed to run without any messages is to temporarily overwrite the system2 function in the base environment. It's not particularly elegant but it works:

# store a copy of system2
assign("system2.default", base::system2, baseenv())

# create a quiet version of system2
assign("system2.quiet", function(...)system2.default(..., stdout = FALSE,
                                                     stderr = FALSE), baseenv())

# overwrite system2 with the quiet version
assignInNamespace("system2", system2.quiet, "base")

# this is now message-free:
res <- eval(suppressMessages(install_github('ROAUth', 'duncantl'))) 

# reset system2 to its original version
assignInNamespace("system2", system2.default, "base")

Answer 2

Another technique would be to patch the devtools functions so that they allow you to pass the stdout argument to system2. Also not very elegant, but perhaps you could convince the package authors to modify devtools in this way. Here are my patched build and install functions:

library(devtools)

# New functions.
my.install<-function (pkg = ".", reload = TRUE, quick = FALSE, args = NULL, ...) 
{
    pkg <- as.package(pkg)
    message("Installing ", pkg$package)
    devtools:::install_deps(pkg)
    built_path <- devtools:::build(pkg, tempdir(),...) # pass along the stdout arg
    on.exit(unlink(built_path))
    opts <- c(paste("--library=", shQuote(.libPaths()[1]), sep = ""), 
        "--with-keep.source")
    if (quick) {
        opts <- c(opts, "--no-docs", "--no-multiarch", "--no-demo")
    }
    opts <- paste(paste(opts, collapse = " "), paste(args, collapse = " "))
    devtools:::R(paste("CMD INSTALL ", shQuote(built_path), " ", opts, sep = ""),...) # pass along the stdout arg
    if (reload) 
        devtools:::reload(pkg)
    invisible(TRUE)
}

my.build<-function (pkg = ".", path = NULL, binary = FALSE, ...) 
{
    pkg <- as.package(pkg)
    if (is.null(path)) {
        path <- dirname(pkg$path)
    }
    if (binary) {
        cmd <- paste("CMD INSTALL ", shQuote(pkg$path), " --build", 
            sep = "")
        ext <- if (.Platform$OS.type == "windows") 
            "zip"
        else "tgz"
    }
    else {
        cmd <- paste("CMD build ", shQuote(pkg$path), " --no-manual --no-resave-data", 
            sep = "")
        ext <- "tar.gz"
    }
    devtools:::R(cmd, path, ...) # pass along the stdout arg
    targz <- paste(pkg$package, "_", pkg$version, ".", ext, sep = "")
    file.path(path, targz)
}

# Patch package.
unlockBinding("install", as.environment("package:devtools"))
unlockBinding("build", as.environment("package:devtools"))
assignInNamespace('install', my.install, ns='devtools', envir=as.environment("package:devtools"));
assignInNamespace('build', my.build, ns='devtools', envir=as.environment("package:devtools"));
lockBinding("install", as.environment("package:devtools"))
lockBinding("build", as.environment("package:devtools"))

# Run with no messages.
suppressMessages(install_github('ROAUth','duncantl',stdout=NULL))

Essentially, you pass along the ... in three places, twice in the install function, and once in the build function.

Answer 3

Here's another possibility. The advantage here is that you don't have to reset system2 after calling install_github: system2 will continue to exhibit its default behavior for all calls except those initiated by a call to install_github():

# store a copy of system2
assign("system2.default", base::system2, baseenv())

# create a quiet version of system2
assign("system2.quiet", function(...)system2.default(..., stdout = FALSE,
                                                     stderr = FALSE), baseenv())
# redefine system2 to use system2.quiet if called from "install_github"
assignInNamespace("system2",
    function(...) {
        cls <- sys.calls()
        from_install_github <- 
            any(sapply(cls, "[[", 1) == as.name("install_github"))
        if(from_install_github) {
            system2.quiet(...)
        } else {
            system2.default(...)
        }},
    "base")


## Try it out
library(devtools)
suppressMessages(install_github('ROAUth', 'duncantl'))

Answer 4

In the case of install.packages, there is a quiet toggle you can enable to suppress the output.

See more at the install.packages documentation.