fix bug reported in #100 (#101)

* Fix java_check_version_rjava() failing on Linux by injecting get_libjvm_path into subprocess

* fix deparse bug and add regression test

Author: e-kotov

R/java_env.R

@@ -305,21 +305,40 @@ java_check_version_rjava <- function(
 
 # Original implementation (not memoised) - used when .use_cache = FALSE
 ._java_version_check_rjava_impl_original <- function(java_home = NULL) {
-  # Get the code of the unexported function to use in a script
-  internal_function <- getFromNamespace(
+  # Get the code of the unexported functions to use in a script
+  # On Linux, the script depends on get_libjvm_path() to avoid crashes in .jinit()
+  java_version_check_fn <- getFromNamespace(
     "java_version_check_rscript",
     "rJavaEnv"
   )
-  script_content <- paste(deparse(body(internal_function)), collapse = "\n")
+  get_libjvm_path_fn <- getFromNamespace("get_libjvm_path", "rJavaEnv")
 
-  # Create a wrapper script that includes the function definition and calls it
-  # Capture current libPaths to ensure subprocess can find rJava in renv/packrat environments
-  libs_code <- paste0(".libPaths(", deparse(as.character(.libPaths())), ")")
+  # Helper to deparse and collapse multi-line expressions
+  deparse_collapse <- function(x) {
+    paste(deparse(x, width.cutoff = 500), collapse = "\n")
+  }
 
-  wrapper_script <- sprintf(
-    "%s\njava_version_check <- function(java_home) {\n%s\n}\n\nargs <- commandArgs(trailingOnly = TRUE)\nresult <- java_version_check(args[1])\ncat(result, sep = '\n')",
-    libs_code,
-    script_content
+  java_version_check_body <- deparse_collapse(body(java_version_check_fn))
+  get_libjvm_path_body <- deparse_collapse(body(get_libjvm_path_fn))
+  libs_val <- deparse_collapse(as.character(.libPaths()))
+
+  # Create a wrapper script that includes the function definitions and calls them
+  # Capture current libPaths to ensure subprocess can find rJava in renv/packrat environments
+  wrapper_script <- paste0(
+    ".libPaths(",
+    libs_val,
+    ")\n\n",
+    "get_libjvm_path <- function(java_home) ",
+    get_libjvm_path_body,
+    "\n\n",
+    "java_version_check <- function(java_home) ",
+    java_version_check_body,
+    "\n\n",
+    "args <- commandArgs(trailingOnly = TRUE)\n",
+    "if (length(args) > 0) {\n",
+    "  result <- java_version_check(args[1])\n",
+    "  cat(result, sep = '\n')\n",
+    "}"
   )
 
   # Write the wrapper script to a temporary file

tests/testthat/test-java_env_subprocess_regression.R

@@ -0,0 +1,73 @@
+#' Test that java_check_version_rjava() correctly constructs the subprocess script
+#' without duplication issues when .libPaths() contains multiple paths.
+
+test_that("._java_version_check_rjava_impl_original handles multi-line .libPaths correctly", {
+  # Mock a scenario where .libPaths() has multiple long paths
+  # This previously caused duplication in paste0() because deparse() returned a vector.
+  mock_paths <- c(
+    "/usr/lib/R/library",
+    "/usr/local/lib/R/site-library",
+    "/home/user/R/x86_64-pc-linux-gnu-library/4.5"
+  )
+
+  captured_script <- NULL
+
+  # Mock get_libjvm_path to return a simple known string
+  local_mocked_bindings(
+    get_libjvm_path = function(...) "/mock/libjvm.so",
+    .package = "rJavaEnv"
+  )
+
+  local_mocked_bindings(
+    .libPaths = function(...) mock_paths,
+    system2 = function(command, args, ...) {
+      # The first argument in args is the script file path
+      if (file.exists(args[1])) {
+        captured_script <<- readLines(args[1])
+      }
+      # Return valid dummy output
+      return(c(
+        "rJava and other rJava/Java-based packages will use Java version: \"21\""
+      ))
+    },
+    .package = "base"
+  )
+
+  # Call the internal function
+  result <- rJavaEnv:::._java_version_check_rjava_impl_original(
+    java_home = "/mock/java"
+  )
+
+  # Assertions on the captured script
+  # Avoid expect_* functions that might trigger 'waldo' dependency issues.
+  # Using simple R logic that throws an error on failure, which testthat will catch.
+  if (is.null(captured_script)) {
+    stop("Captured script is NULL")
+  }
+
+  # 1. Check for duplication of function definitions
+  def_count <- sum(grepl("java_version_check <- function", captured_script))
+  if (!identical(as.numeric(def_count), 1)) {
+    stop(sprintf(
+      "The function definition should appear exactly once, but found %d",
+      def_count
+    ))
+  }
+
+  # 2. Check that .libPaths() contains all paths in a valid call
+  script_text <- paste(captured_script, collapse = "\n")
+  if (!grepl("\\.libPaths\\(c\\(", script_text)) {
+    stop("Should use c() for multiple library paths.")
+  }
+  if (!grepl("/home/user/R/x86_64-pc-linux-gnu-library/4.5", script_text)) {
+    stop("Last path should be present.")
+  }
+
+  # 3. Check for syntax errors (no stray commas at line ends from bad paste)
+  if (grepl(", \\)", script_text)) {
+    stop("Malformed closing parenthesis found.")
+  }
+
+  # Final verification: if we reached here, the test passed.
+  expect_silent(NULL)
+})