Support renv profiles

R/bundlePackage.R

@@ -58,7 +58,7 @@ computePackageDependencies <- function(
       extraPackages,
       verbose = verbose
     )
-  } else if (file.exists(renvLockFile(bundleDir))) {
+  } else if (ensureRenvLockFile(bundleDir)) {
     # This ignores extraPackages; if you're using a lockfile it's your
     # responsibility to install any other packages you need
     taskStart(quiet, "Capturing R dependencies from renv.lock")

R/bundlePackageRenv.R

@@ -30,6 +30,10 @@ snapshotRenvDependencies <- function(
     progress = FALSE
   )
   renv::snapshot(bundleDir, packages = deps$Package, prompt = FALSE)
+  # renv::snapshot() respects RENV_PATHS_LOCKFILE and renv profiles, so the
+  # lockfile may have been written to a non-standard location. Copy it into the
+  # bundle dir so parseRenvDependencies() can find it.
+  ensureRenvLockFile(bundleDir)
   defer(removeRenv(bundleDir))
 
   parseRenvDependencies(bundleDir, snapshot = TRUE)
@@ -172,6 +176,41 @@ renvLockFile <- function(bundleDir) {
   file.path(bundleDir, "renv.lock")
 }
 
+# Ensure the renv lockfile is at the standard bundle location.
+# If found at a custom location (via RENV_PATHS_LOCKFILE or renv profiles),
+# copies it into bundleDir/renv.lock, overwriting any stale lockfile.
+# Returns TRUE if the lockfile is available, FALSE otherwise.
+ensureRenvLockFile <- function(bundleDir) {
+  standard <- renvLockFile(bundleDir)
+  resolved <- renv::paths$lockfile(project = bundleDir)
+
+  # If the resolved file exists, and is different from the standard location,
+  # copy it to the standard location.
+  if (file.exists(resolved)) {
+    # Normalize to avoid self-copy (e.g., /var vs /private/var on macOS)
+    if (
+      normalizePath(resolved, mustWork = FALSE) !=
+        normalizePath(standard, mustWork = FALSE)
+    ) {
+      if (file.exists(standard)) {
+        cli::cli_warn(c(
+          "Using lockfile at {.path {resolved}} instead of {.path {standard}}.",
+          i = "The lockfile in the project root may be outdated.",
+          i = "Remove it to silence this warning."
+        ))
+      }
+      if (!file.copy(resolved, standard, overwrite = TRUE)) {
+        cli::cli_abort(
+          "Failed to copy lockfile from {.path {resolved}} to {.path {standard}}."
+        )
+      }
+    }
+    return(TRUE)
+  }
+
+  file.exists(standard)
+}
+
 removeRenv <- function(path, lockfile = TRUE) {
   if (lockfile) {
     unlink(renvLockFile(path))

tests/testthat/_snaps/bundlePackage.md

@@ -30,6 +30,35 @@
       i Capturing R dependencies from renv.lock
       v Found 3 dependencies
 
+# can capture deps from renv lockfile in custom location (RENV_PATHS_LOCKFILE)
+
+    Code
+      pkgs <- bundlePackages(app_dir)
+    Message
+      i Capturing R dependencies from renv.lock
+      v Found 3 dependencies
+
+# warns when custom lockfile overwrites existing standard lockfile
+
+    Code
+      pkgs <- bundlePackages(app_dir)
+    Condition
+      Warning:
+      Using lockfile at '<path>' instead of '<path>'.
+      i The lockfile in the project root may be outdated.
+      i Remove it to silence this warning.
+    Message
+      i Capturing R dependencies from renv.lock
+      v Found 3 dependencies
+
+# can capture deps from renv lockfile with renv profile
+
+    Code
+      pkgs <- bundlePackages(app_dir)
+    Message
+      i Capturing R dependencies from renv.lock
+      v Found 3 dependencies
+
 # can capture deps with packrat even when renv lockfile present
 
     Code

tests/testthat/test-bundlePackage.R

@@ -71,6 +71,83 @@ test_that("can capture deps from renv lockfile", {
   expect_equal(list.files(app_dir), c("foo.R", "renv.lock"))
 })
 
+test_that("can capture deps from renv lockfile in custom location (RENV_PATHS_LOCKFILE)", {
+  skip_if_not_installed("foreign")
+  skip_if_not_installed("MASS")
+
+  withr::local_options(renv.verbose = FALSE)
+
+  app_dir <- local_temp_app(list(foo.R = "library(foreign); library(MASS)"))
+
+  # Create renv.lock in the standard location first
+
+  renv::snapshot(app_dir, prompt = FALSE)
+
+  # Move the lockfile to a custom location outside the app dir
+  custom_lock_dir <- withr::local_tempdir()
+  custom_lock_path <- file.path(custom_lock_dir, "renv.lock")
+  file.rename(file.path(app_dir, "renv.lock"), custom_lock_path)
+
+  # Set RENV_PATHS_LOCKFILE to point to the custom location
+  withr::local_envvar(RENV_PATHS_LOCKFILE = custom_lock_path)
+
+  # Should find the lockfile at the custom location and capture deps.
+  expect_snapshot(pkgs <- bundlePackages(app_dir))
+
+  # renv is included by the renv.lock
+  expect_named(pkgs, c("foreign", "MASS", "renv"), ignore.order = TRUE)
+  expect_named(pkgs$foreign, c("Source", "Repository", "description"))
+  expect_named(pkgs$MASS, c("Source", "Repository", "description"))
+})
+
+test_that("warns when custom lockfile overwrites existing standard lockfile", {
+  skip_if_not_installed("foreign")
+  skip_if_not_installed("MASS")
+
+  withr::local_options(renv.verbose = FALSE)
+
+  app_dir <- local_temp_app(list(foo.R = "library(foreign); library(MASS)"))
+
+  # Create renv.lock in the standard location
+  renv::snapshot(app_dir, prompt = FALSE)
+
+  # Copy the lockfile to a custom location, leaving the original in place
+  custom_lock_dir <- withr::local_tempdir()
+  custom_lock_path <- file.path(custom_lock_dir, "renv.lock")
+  file.copy(file.path(app_dir, "renv.lock"), custom_lock_path)
+
+  # Set RENV_PATHS_LOCKFILE to point to the custom location
+  withr::local_envvar(RENV_PATHS_LOCKFILE = custom_lock_path)
+
+  # Should warn about overwriting the standard lockfile
+  expect_snapshot(pkgs <- bundlePackages(app_dir), transform = function(x) {
+    gsub("'[^']+'", "'<path>'", x)
+  })
+
+  expect_named(pkgs, c("foreign", "MASS", "renv"), ignore.order = TRUE)
+})
+
+test_that("can capture deps from renv lockfile with renv profile", {
+  skip_if_not_installed("foreign")
+  skip_if_not_installed("MASS")
+
+  withr::local_options(renv.verbose = FALSE)
+
+  app_dir <- local_temp_app(list(foo.R = "library(foreign); library(MASS)"))
+
+  # Set RENV_PROFILE so renv resolves the lockfile from the profile path
+  withr::local_envvar(RENV_PROFILE = "testing")
+  renv::snapshot(app_dir, prompt = FALSE)
+
+  # Should find the lockfile at the profile location and capture deps.
+  expect_snapshot(pkgs <- bundlePackages(app_dir))
+
+  # renv is included by the renv.lock
+  expect_named(pkgs, c("foreign", "MASS", "renv"), ignore.order = TRUE)
+  expect_named(pkgs$foreign, c("Source", "Repository", "description"))
+  expect_named(pkgs$MASS, c("Source", "Repository", "description"))
+})
+
 test_that("can capture deps with packrat even when renv lockfile present", {
   skip_if_not_installed("foreign")
   skip_if_not_installed("MASS")