provide exported functions for interacting with lockfiles

NAMESPACE

@@ -17,6 +17,10 @@ export(init)
 export(install)
 export(isolate)
 export(load)
+export(lockfile_create)
+export(lockfile_modify)
+export(lockfile_read)
+export(lockfile_write)
 export(migrate)
 export(modify)
 export(paths)

R/lockfiles.R

@@ -96,7 +96,86 @@
 #' Note that the `Name` field may be empty. In that case, a project-local Python
 #' environment will be used instead (when not directly using a system copy of Python).
 #'
+#' # Caveats
+#'
+#' These functions are primarily intended for expert users -- in most cases,
+#' [snapshot()] and [restore()] are the primariy tools you will need when
+#' creating and using lockfiles.
+#'
+#' @inheritParams snapshot
+#' @inheritParams renv-params
+#'
+#' @param lockfile An `renv` lockfile; typically created by either
+#'   `lockfile_create()` or `lockfile_read()`.
+#'
+#' @param file A file path, or \R connection.
+#'
 #' @family reproducibility
-#' @name lockfiles
-#' @rdname lockfiles
+#' @name lockfile
+#' @rdname lockfile
 NULL
+
+#' @param libpaths The library paths to be used when generating the lockfile.
+#' @rdname lockfile
+#' @export
+lockfile_create <- function(type = settings$snapshot.type(project = project),
+                            libpaths = .libPaths(),
+                            packages = NULL,
+                            exclude = NULL,
+                            ...,
+                            project = NULL)
+{
+  project <- renv_project_resolve(project)
+
+  renv_lockfile_create(
+    project = project,
+    libpaths = libpaths,
+    type = type,
+    packages = packages,
+    exclude = exclude
+  )
+}
+
+#' @rdname lockfile
+#' @export
+lockfile_read <- function(file = NULL, ..., project = NULL) {
+  project <- renv_project_resolve(project)
+  file <- file %||% renv_paths_lockfile(project = project)
+  renv_lockfile_read(file = file)
+}
+
+#' @rdname lockfile
+#' @export
+lockfile_write <- function(lockfile, file = NULL, ..., project = NULL) {
+  project <- renv_project_resolve(project)
+  file <- file %||% renv_paths_lockfile(project = project)
+  renv_lockfile_write(lockfile, file = file)
+}
+
+#' @param remotes A named \R list, mapping package names to the remote
+#'   specifications to be recorded in the lockfile.
+#'
+#' @param repos A named vector, mapping \R repository names to their URLs.
+#'
+#' @rdname lockfile
+#' @export
+lockfile_modify <- function(lockfile,
+                            ...,
+                            remotes = NULL,
+                            repos = NULL)
+{
+  if (!is.null(repos)) {
+    lockfile$R$Repositories <- as.list(repos)
+  }
+
+  if (!is.null(remotes)) {
+    remotes <- renv_records_resolve(remotes)
+    enumerate(remotes, function(package, remote) {
+      record <- renv_remotes_resolve(remote)
+      renv_lockfile_records(lockfile)[[package]] <<- record
+    })
+  }
+
+  lockfile
+
+}

R/paths.R

@@ -305,7 +305,7 @@ renv_paths_root_default_tempdir <- function() {
 #' \code{RENV_PATHS_LIBRARY_ROOT}    \tab The parent path for project libraries. \cr
 #' \code{RENV_PATHS_LIBRARY_STAGING} \tab The parent path used for staged package installs. \cr
 #' \code{RENV_PATHS_SANDBOX}         \tab The path to the sandboxed \R system library. \cr
-#' \code{RENV_PATHS_LOCKFILE}        \tab The path to the [lockfile][lockfiles]. \cr
+#' \code{RENV_PATHS_LOCKFILE}        \tab The path to the [lockfile]. \cr
 #' \code{RENV_PATHS_CELLAR}          \tab The path to the cellar, containing local package binaries and sources. \cr
 #' \code{RENV_PATHS_SOURCE}          \tab The path containing downloaded package sources. \cr
 #' \code{RENV_PATHS_BINARY}          \tab The path containing downloaded package binaries. \cr

R/r.R

@@ -48,7 +48,6 @@ r_exec_error <- function(package, output, label, extra) {
     message = sprintf("%s of package '%s' failed [%s]", label, package, extra),
     detail = all
   )
-  stop(error)
 
 }
 

R/repair.R

@@ -48,7 +48,6 @@ repair <- function(library  = NULL,
 renv_repair_records <- function(packages, lockfile, project) {
 
   lockfile <- lockfile %||% renv_paths_lockfile(project = project)
-  lockfile <- renv_lockfile_resolve(lockfile)
   if (is.null(lockfile))
     return(packages)
 

R/restore.R

@@ -56,7 +56,6 @@ restore <- function(project  = NULL,
   # resolve library, lockfile arguments
   libpaths <- renv_libpaths_resolve(library)
   lockfile <- lockfile %||% renv_lockfile_load(project = project)
-  lockfile <- renv_lockfile_resolve(lockfile)
 
   # activate the requested library (place at front of library paths)
   library <- nth(libpaths, 1L)

R/scaffold.R

@@ -16,7 +16,7 @@
 #' - Create `.Rbuildignore`, if the project is also a package. This tells
 #'   `R CMD build` to ignore the renv infrastructure,
 #'
-#' - Write a (bare) [lockfile][lockfiles], `renv.lock`.
+#' - Write a (bare) [lockfile], `renv.lock`.
 #'
 #' @inheritParams renv-params
 #'

R/snapshot.R

@@ -6,9 +6,9 @@
 #' Record current state of the project library in the lockfile
 #'
 #' @description
-#' Call `renv::snapshot()` to update a [lockfile][lockfiles] with the current
-#' state of dependencies in the project library. The lockfile can be used to
-#' later [restore] these dependencies as required.
+#' Call `renv::snapshot()` to update a [lockfile] with the current state of
+#' dependencies in the project library. The lockfile can be used to later
+#' [restore] these dependencies as required.
 #'
 #' It's also possible to call `renv::snapshot()` with a non-renv project,
 #' in which case it will record the current state of dependencies in the

inst/resources/activate.R

@@ -416,7 +416,7 @@ local({
       on.exit(do.call(base::options, saved), add = TRUE)
     }
 
-    catf("* Downloading from GitHub ... ", appendLF = FALSE)
+    catf("* Downloading version %s from GitHub ... ", version, appendLF = FALSE)
 
     url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version)
     name <- sprintf("renv_%s.tar.gz", version)