|
| 1 | +local({ |
| 2 | + |
| 3 | + ## Helper function to get the path to the library directory for a |
| 4 | + ## given packrat project. |
| 5 | + getPackratLibDir <- function(projDir = NULL) { |
| 6 | + path <- file.path("packrat", "lib", R.version$platform, getRversion()) |
| 7 | + |
| 8 | + if (!is.null(projDir)) { |
| 9 | + |
| 10 | + ## Strip trailing slashes if necessary |
| 11 | + projDir <- sub("/+$", "", projDir) |
| 12 | + |
| 13 | + ## Only prepend path if different from current working dir |
| 14 | + if (!identical(normalizePath(projDir), normalizePath(getwd()))) |
| 15 | + path <- file.path(projDir, path) |
| 16 | + } |
| 17 | + |
| 18 | + path |
| 19 | + } |
| 20 | + |
| 21 | + ## Ensure that we set the packrat library directory relative to the |
| 22 | + ## project directory. Normally, this should be the working directory, |
| 23 | + ## but we also use '.rs.getProjectDirectory()' if necessary (e.g. we're |
| 24 | + ## rebuilding a project while within a separate directory) |
| 25 | + libDir <- if (exists(".rs.getProjectDirectory")) |
| 26 | + getPackratLibDir(.rs.getProjectDirectory()) |
| 27 | + else |
| 28 | + getPackratLibDir() |
| 29 | + |
| 30 | + ## Unload packrat in case it's loaded -- this ensures packrat _must_ be |
| 31 | + ## loaded from the private library. Note that `requireNamespace` will |
| 32 | + ## succeed if the package is already loaded, regardless of lib.loc! |
| 33 | + if ("packrat" %in% loadedNamespaces()) |
| 34 | + try(unloadNamespace("packrat"), silent = TRUE) |
| 35 | + |
| 36 | + if (suppressWarnings(requireNamespace("packrat", quietly = TRUE, lib.loc = libDir))) { |
| 37 | + |
| 38 | + # Check 'print.banner.on.startup' -- when NA and RStudio, don't print |
| 39 | + print.banner <- packrat::get_opts("print.banner.on.startup") |
| 40 | + if (print.banner == "auto" && is.na(Sys.getenv("RSTUDIO", unset = NA))) { |
| 41 | + print.banner <- TRUE |
| 42 | + } else { |
| 43 | + print.banner <- FALSE |
| 44 | + } |
| 45 | + return(packrat::on(print.banner = print.banner)) |
| 46 | + } |
| 47 | + |
| 48 | + ## Escape hatch to allow RStudio to handle bootstrapping. This |
| 49 | + ## enables RStudio to provide print output when automagically |
| 50 | + ## restoring a project from a bundle on load. |
| 51 | + if (!is.na(Sys.getenv("RSTUDIO", unset = NA)) && |
| 52 | + is.na(Sys.getenv("RSTUDIO_PACKRAT_BOOTSTRAP", unset = NA))) { |
| 53 | + Sys.setenv("RSTUDIO_PACKRAT_BOOTSTRAP" = "1") |
| 54 | + setHook("rstudio.sessionInit", function(...) { |
| 55 | + # Ensure that, on sourcing 'packrat/init.R', we are |
| 56 | + # within the project root directory |
| 57 | + if (exists(".rs.getProjectDirectory")) { |
| 58 | + owd <- getwd() |
| 59 | + setwd(.rs.getProjectDirectory()) |
| 60 | + on.exit(setwd(owd), add = TRUE) |
| 61 | + } |
| 62 | + source("packrat/init.R") |
| 63 | + }) |
| 64 | + return(invisible(NULL)) |
| 65 | + } |
| 66 | + |
| 67 | + ## Bootstrapping -- only performed in interactive contexts, |
| 68 | + ## or when explicitly asked for on the command line |
| 69 | + if (interactive() || "--bootstrap-packrat" %in% commandArgs(TRUE)) { |
| 70 | + |
| 71 | + message("Packrat is not installed in the local library -- ", |
| 72 | + "attempting to bootstrap an installation...") |
| 73 | + |
| 74 | + ## We need utils for the following to succeed -- there are calls to functions |
| 75 | + ## in 'restore' that are contained within utils. utils gets loaded at the |
| 76 | + ## end of start-up anyhow, so this should be fine |
| 77 | + library("utils", character.only = TRUE) |
| 78 | + |
| 79 | + ## Install packrat into local project library |
| 80 | + packratSrcPath <- list.files(full.names = TRUE, |
| 81 | + file.path("packrat", "src", "packrat") |
| 82 | + ) |
| 83 | + |
| 84 | + ## No packrat tarballs available locally -- try some other means of installation |
| 85 | + if (!length(packratSrcPath)) { |
| 86 | + |
| 87 | + message("> No source tarball of packrat available locally") |
| 88 | + |
| 89 | + ## There are no packrat sources available -- try using a version of |
| 90 | + ## packrat installed in the user library to bootstrap |
| 91 | + if (requireNamespace("packrat", quietly = TRUE) && packageVersion("packrat") >= "0.2.0.99") { |
| 92 | + message("> Using user-library packrat (", |
| 93 | + packageVersion("packrat"), |
| 94 | + ") to bootstrap this project") |
| 95 | + } |
| 96 | + |
| 97 | + ## Couldn't find a user-local packrat -- try finding and using devtools |
| 98 | + ## to install |
| 99 | + else if (requireNamespace("devtools", quietly = TRUE)) { |
| 100 | + message("> Attempting to use devtools::install_github to install ", |
| 101 | + "a temporary version of packrat") |
| 102 | + library(stats) ## for setNames |
| 103 | + devtools::install_github("rstudio/packrat") |
| 104 | + } |
| 105 | + |
| 106 | + ## Try downloading packrat from CRAN if available |
| 107 | + else if ("packrat" %in% rownames(available.packages())) { |
| 108 | + message("> Installing packrat from CRAN") |
| 109 | + install.packages("packrat") |
| 110 | + } |
| 111 | + |
| 112 | + ## Fail -- couldn't find an appropriate means of installing packrat |
| 113 | + else { |
| 114 | + stop("Could not automatically bootstrap packrat -- try running ", |
| 115 | + "\"'install.packages('devtools'); devtools::install_github('rstudio/packrat')\"", |
| 116 | + "and restarting R to bootstrap packrat.") |
| 117 | + } |
| 118 | + |
| 119 | + # Restore the project, unload the temporary packrat, and load the private packrat |
| 120 | + packrat::restore(prompt = FALSE, restart = TRUE) |
| 121 | + |
| 122 | + ## This code path only reached if we didn't restart earlier |
| 123 | + unloadNamespace("packrat") |
| 124 | + requireNamespace("packrat", lib.loc = libDir, quietly = TRUE) |
| 125 | + return(packrat::on()) |
| 126 | + |
| 127 | + } |
| 128 | + |
| 129 | + ## Multiple packrat tarballs available locally -- try to choose one |
| 130 | + ## TODO: read lock file and infer most appropriate from there; low priority because |
| 131 | + ## after bootstrapping packrat a restore should do the right thing |
| 132 | + if (length(packratSrcPath) > 1) { |
| 133 | + warning("Multiple versions of packrat available in the source directory;", |
| 134 | + "using packrat source:\n- ", shQuote(packratSrcPath)) |
| 135 | + packratSrcPath <- packratSrcPath[[1]] |
| 136 | + } |
| 137 | + |
| 138 | + |
| 139 | + lib <- file.path("packrat", "lib", R.version$platform, getRversion()) |
| 140 | + if (!file.exists(lib)) { |
| 141 | + dir.create(lib, recursive = TRUE) |
| 142 | + } |
| 143 | + lib <- normalizePath(lib, winslash = "/") |
| 144 | + |
| 145 | + message("> Installing packrat into project private library:") |
| 146 | + message("- ", shQuote(lib)) |
| 147 | + |
| 148 | + surround <- function(x, with) { |
| 149 | + if (!length(x)) return(character()) |
| 150 | + paste0(with, x, with) |
| 151 | + } |
| 152 | + |
| 153 | + ## The following is performed because a regular install.packages call can fail |
| 154 | + peq <- function(x, y) paste(x, y, sep = " = ") |
| 155 | + installArgs <- c( |
| 156 | + peq("pkgs", surround(packratSrcPath, with = "'")), |
| 157 | + peq("lib", surround(lib, with = "'")), |
| 158 | + peq("repos", "NULL"), |
| 159 | + peq("type", surround("source", with = "'")) |
| 160 | + ) |
| 161 | + installCmd <- paste(sep = "", |
| 162 | + "utils::install.packages(", |
| 163 | + paste(installArgs, collapse = ", "), |
| 164 | + ")") |
| 165 | + |
| 166 | + fullCmd <- paste( |
| 167 | + surround(file.path(R.home("bin"), "R"), with = "\""), |
| 168 | + "--vanilla", |
| 169 | + "--slave", |
| 170 | + "-e", |
| 171 | + surround(installCmd, with = "\"") |
| 172 | + ) |
| 173 | + system(fullCmd) |
| 174 | + |
| 175 | + ## Tag the installed packrat so we know it's managed by packrat |
| 176 | + ## TODO: should this be taking information from the lockfile? this is a bit awkward |
| 177 | + ## because we're taking an un-annotated packrat source tarball and simply assuming it's now |
| 178 | + ## an 'installed from source' version |
| 179 | + |
| 180 | + ## -- InstallAgent -- ## |
| 181 | + installAgent <- 'InstallAgent: packrat 0.4.6-1' |
| 182 | + |
| 183 | + ## -- InstallSource -- ## |
| 184 | + installSource <- 'InstallSource: source' |
| 185 | + |
| 186 | + packratDescPath <- file.path(lib, "packrat", "DESCRIPTION") |
| 187 | + DESCRIPTION <- readLines(packratDescPath) |
| 188 | + DESCRIPTION <- c(DESCRIPTION, installAgent, installSource) |
| 189 | + cat(DESCRIPTION, file = packratDescPath, sep = "\n") |
| 190 | + |
| 191 | + # Otherwise, continue on as normal |
| 192 | + message("> Attaching packrat") |
| 193 | + library("packrat", character.only = TRUE, lib.loc = lib) |
| 194 | + |
| 195 | + message("> Restoring library") |
| 196 | + restore(restart = FALSE) |
| 197 | + |
| 198 | + # If the environment allows us to restart, do so with a call to restore |
| 199 | + restart <- getOption("restart") |
| 200 | + if (!is.null(restart)) { |
| 201 | + message("> Packrat bootstrap successfully completed. ", |
| 202 | + "Restarting R and entering packrat mode...") |
| 203 | + return(restart()) |
| 204 | + } |
| 205 | + |
| 206 | + # Callers (source-erers) can define this hidden variable to make sure we don't enter packrat mode |
| 207 | + # Primarily useful for testing |
| 208 | + if (!exists(".__DONT_ENTER_PACKRAT_MODE__.") && interactive()) { |
| 209 | + message("> Packrat bootstrap successfully completed. Entering packrat mode...") |
| 210 | + packrat::on() |
| 211 | + } |
| 212 | + |
| 213 | + Sys.unsetenv("RSTUDIO_PACKRAT_BOOTSTRAP") |
| 214 | + |
| 215 | + } |
| 216 | + |
| 217 | +}) |
0 commit comments